Refactor of renaming ov libraries for layer tests with key --use_new_frontend (#12846)

* refactor of renaming libraries in layer tests

* 1. adds check for old API and new FE usafe
2. refactor of api_2 arg

* fix for tf_NMS test preprocessing

* take libs path from LD_LIBRARY_PATH env

* convert str to Path object

* use wheels path to libs

* print lib paths

* print lib paths

* use ov_frontend_path env

* also check if file to rename exists

* removes redundant prints

* copy instead of rename

* 1. copy instead of rename
2. adds some details to readme

tests/layer_tests/README.md

@@ -14,11 +14,15 @@ This folder layer tests framework code and test files.
     ```bash
     pip3 install -r requirements.txt
     ```
-* Set up environment variables for layer tests:
+* Set up environment variables for layer tests (if you use wheel package path to python api could be removed):
     ```bash
     export PYTHONPATH="path_to_openvino"/tests/layer_tests/:"path_to_openvino"/tools/mo:"path to python api"
     ```
-  To parametrize tests by device and precision (optional)
+* If there is need to use specific libs it is possible to specify path to them using OV_LIBRARY_PATH env variable
+    ```bash
+    export OV_LIBRARY_PATH="path_to_libs"
+    ```
+* To parametrize tests by device and precision (optional)
    ```bash
    export TEST_DEVICE="CPU;GPU"
    export TEST_PRECISION="FP32;FP16"

tests/layer_tests/common/layer_test_class.py

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import itertools
-import numpy as np
 import os
 import re
 import warnings
@@ -12,7 +11,6 @@ from pathlib import Path
 import numpy as np
 from common.constants import test_device, test_precision
 from common.layer_utils import IEInfer, InferAPI20
-from openvino.tools.mo.utils.ir_engine.ir_engine import IREngine
 from common.utils.common_utils import generate_ir
 from common.utils.parsers import mapping_parser
 
@@ -28,7 +26,7 @@ class CommonLayerTest:
         raise RuntimeError("This is base class, please implement get_framework_results function for"
                            " the specific framework")
 
-    def _test(self, framework_model, ref_net, ie_device, precision, ir_version, temp_dir, api_2,
+    def _test(self, framework_model, ref_net, ie_device, precision, ir_version, temp_dir, use_old_api,
               use_new_frontend=True, infer_timeout=60, enabled_transforms='',
               disabled_transforms='', **kwargs):
         """
@@ -38,7 +36,7 @@ class CommonLayerTest:
         model_path = self.produce_model_path(framework_model=framework_model, save_path=temp_dir)
 
         self.use_new_frontend = use_new_frontend
-        self.api_2 = api_2
+        self.use_old_api = use_old_api
         # TODO Pass environment variables via subprocess environment
         os.environ['MO_ENABLED_TRANSFORMS'] = enabled_transforms
         os.environ['MO_DISABLED_TRANSFORMS'] = disabled_transforms
@@ -78,15 +76,14 @@ class CommonLayerTest:
         #     (flag, resp) = ir.compare(ref_net)
         #     assert flag, '\n'.join(resp)
 
-        if api_2:
-            ie_engine = InferAPI20(model=path_to_xml,
-                                   weights=path_to_bin,
-                                   device=ie_device)
-        else:
+        if self.use_old_api:
             ie_engine = IEInfer(model=path_to_xml,
                                 weights=path_to_bin,
                                 device=ie_device)
-
+        else:
+            ie_engine = InferAPI20(model=path_to_xml,
+                                   weights=path_to_bin,
+                                   device=ie_device)
         # Prepare feed dict
         if 'kwargs_to_prepare_input' in kwargs and kwargs['kwargs_to_prepare_input']:
             inputs_dict = self._prepare_input(ie_engine.get_inputs_info(precision),

tests/layer_tests/common/tf_layer_test_class.py

@@ -7,8 +7,8 @@ from common.layer_test_class import CommonLayerTest
 from common.utils.tf_utils import summarize_graph
 
 
-def transpose_nchw_to_nhwc(data, use_new_frontend, api_2):
-    if use_new_frontend or api_2:
+def transpose_nchw_to_nhwc(data, use_new_frontend, use_old_api):
+    if use_new_frontend or not use_old_api:
         return data
 
     if len(data.shape) == 4:  # reshaping for 4D tensors
@@ -19,8 +19,8 @@ def transpose_nchw_to_nhwc(data, use_new_frontend, api_2):
         return data
 
 
-def transpose_nhwc_to_nchw(data, use_new_frontend, api_2):
-    if use_new_frontend or api_2:
+def transpose_nhwc_to_nchw(data, use_new_frontend, use_old_api):
+    if use_new_frontend or not use_old_api:
         return data
 
     if len(data.shape) == 4:  # reshaping for 4D tensors
@@ -62,14 +62,11 @@ class CommonTFLayerTest(CommonLayerTest):
                 tf.compat.v1.import_graph_def(graph_def, name='')
 
                 input = dict()
-                if self.api_2:
-                    input.update(inputs_dict)
-                else:
                 for key in inputs_dict.keys():
                     data = inputs_dict.get(key)
-                        if not self.api_2:
+                    if self.use_old_api or self.use_new_frontend:
                         key += ':0'
-                        input[key] = transpose_nchw_to_nhwc(data, self.use_new_frontend, self.api_2)
+                    input[key] = transpose_nchw_to_nhwc(data, self.use_new_frontend, self.use_old_api)
 
                 tf_res = sess.run([out + ":0" for out in outputs_list], input)
 
@@ -77,5 +74,5 @@ class CommonTFLayerTest(CommonLayerTest):
                 for i, output in enumerate(outputs_list):
                     _tf_res = tf_res[i]
                     result[output] = transpose_nhwc_to_nchw(_tf_res, self.use_new_frontend,
-                                                            self.api_2)
+                                                            self.use_old_api)
                 return result

tests/layer_tests/common/utils/common_utils.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -88,10 +88,12 @@ def allclose(cur_array, ref_array, atol, rtol):
     return ((abs_diff < atol) | (abs_diff < rtol * max_val)).all()
 
 
-def rename_ov_lib(files_to_rename: list, lib_dir: Path):
-    for pair in files_to_rename:
-        current_lib_path = os.path.join(lib_dir, pair[0])
-        new_lib_path = os.path.join(lib_dir, pair[1])
-        if os.path.exists(current_lib_path):
-            logging.info('Renaming library from {} to {}'.format(current_lib_path, new_lib_path))
-            os.replace(current_lib_path, new_lib_path)
+def copy_files_by_pattern(directory: Path, pattern_to_find: str, pattern_to_copy: str):
+    for file in directory.glob("{}*".format(pattern_to_find)):
+        file_extension = ''.join(file.suffixes)
+        copied_file = file.parent / (pattern_to_copy + file_extension)
+        if not copied_file.exists() and file.exists():
+            logging.info('Copying file from {} to {}'.format(file, copied_file))
+            shutil.copy(str(file), str(copied_file))
+        else:
+            logging.info('File {} already exist or file {} does not exist'.format(copied_file, file))

tests/layer_tests/conftest.py

@@ -2,10 +2,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import re
-from pathlib import Path
 import tempfile
+from pathlib import Path
 
 import pytest
+
 from common import constants
 
 
@@ -65,10 +66,10 @@ def pytest_addoption(parser):
         action="store_true",
         help="Use Model Optimizer with new FrontEnd")
     parser.addoption(
-        "--api_2",
+        "--use_old_api",
         action="store_true",
-        help="Use new API 2.0 for model processing in Inference Engine",
-        default=True)
+        help="Use old API for model processing in Inference Engine",
+    )
 
 
 @pytest.fixture(scope="session")
@@ -84,9 +85,15 @@ def use_new_frontend(request):
 
 
 @pytest.fixture(scope="session")
-def api_2(request):
+def use_old_api(request):
     """Fixture function for command-line option."""
-    return request.config.getoption('api_2')
+    return request.config.getoption('use_old_api')
+
+
+@pytest.fixture(scope="session", autouse=True)
+def checks_for_keys_usage(request):
+    if request.config.getoption('use_old_api') and request.config.getoption('use_new_frontend'):
+        pytest.fail("Old API and new FrontEnd usage detected. Old API doesn't support new FrontEnd")
 
 
 @pytest.fixture(scope="function")

tests/layer_tests/onnx_tests/test_abs.py

@@ -167,12 +167,12 @@ class TestAbs(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_abs(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_abs(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_abs_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_abs_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_add_sub_mul_div.py

@@ -194,160 +194,160 @@ class TestOperations(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_add(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Add', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_add_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Add', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sub(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Sub', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sub_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Sub', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_mul(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Mul', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_mul_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Mul', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_div(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Div', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_div_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Div', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_add_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Add', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_add_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Add', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_sub_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Sub', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_sub_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Sub', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_mul_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Mul', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_mul_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Mul', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_div_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Div', precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_div_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, op='Div', precision=precision, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_add_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Add', precision=precision, opset=6,
                                     ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_add_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_add_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, op='Add', precision=precision, opset=6,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sub_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Sub', precision=precision, opset=6,
                                     ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sub_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sub_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, op='Sub', precision=precision, opset=6,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_mul_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Mul', precision=precision, opset=6,
                                     ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_mul_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mul_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, op='Mul', precision=precision, opset=6,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_div_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, op='Div', precision=precision, opset=6,
                                     ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_div_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_div_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, op='Div', precision=precision, opset=6,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_and.py

@@ -251,21 +251,21 @@ class TestAnd(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_and(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_and(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_and_one_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_and_one_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_one_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_and_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_and_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_argmax.py

@@ -150,6 +150,6 @@ class TestArgMax(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keepdims", [None, 0])
     @pytest.mark.nightly
-    def test_argmax(self, params, keepdims, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_argmax(self, params, keepdims, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, keepdims=keepdims),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_bn.py

@@ -116,18 +116,18 @@ class TestBatchNormalization(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_bn(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_bn(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_bn_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_bn_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=6, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_bn_opset7(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_bn_opset7(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=7, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_ceil.py

@@ -171,26 +171,26 @@ class TestCeil(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_ceil_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_ceil_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_ceil_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_ceil_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_ceil(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_ceil(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_ceil_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_ceil_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_clip.py

@@ -160,14 +160,14 @@ class TestClip(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_clip_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_clip_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, opset=6), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_clip_opset11(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_clip_opset11(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, opset=11), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_concat.py

@@ -252,39 +252,39 @@ class TestConcat(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_concat_3D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_concat_3D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_concat_net_const(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_precommit)
     @pytest.mark.precommit
     def test_concat_4D_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                       api_2):
+                                       use_old_api):
         self._test(*self.create_concat_net_const(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_concat_4D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_concat_4D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_concat_net_const(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D_precommit)
     @pytest.mark.nightly
     def test_concat_5D_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                       api_2):
+                                       use_old_api):
         self._test(*self.create_concat_net_const(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_concat_5D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_concat_5D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_concat_net_const(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_concat_inputs_order_params)
     @pytest.mark.nightly
-    def test_concat_inputs_order(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_concat_inputs_order(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version), ie_device=ie_device,
                    precision=precision, ir_version=ir_version, temp_dir=temp_dir,
-                   input_names=params['input_names'], api_2=api_2)
+                   input_names=params['input_names'], use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_conv.py

@@ -414,11 +414,11 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.nightly
     def test_conv_3D(self, params, dilations, pads, strides, bias, ie_device, precision, ir_version,
-                     temp_dir, api_2):
+                     temp_dir, use_old_api):
         self._test(*self.create_net(**params, shape=[2, 3, 25], dilations=dilations, pads=pads,
                                     strides=strides,
                                     bias=bias, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D_autopad[:-1])
     @pytest.mark.parametrize("auto_pad", ['SAME_UPPER', 'SAME_LOWER'])
@@ -426,10 +426,10 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.xfail(reason='autopad dimetions do not agree with framework')
     def test_conv_3D_autopad(self, params, auto_pad, bias, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         self._test(*self.create_net(**params, shape=[2, 3, 25], bias=bias, auto_pad=auto_pad,
                                     ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_precommit)
     @pytest.mark.parametrize("dilations", [[3, 5]])
@@ -438,11 +438,11 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.precommit
     def test_conv_4D_precommit(self, params, dilations, pads, strides, bias, ie_device, precision,
-                               ir_version, temp_dir, api_2):
+                               ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, shape=[2, 3, 25, 25], dilations=dilations, pads=pads,
                                     strides=strides,
                                     bias=bias, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.parametrize("dilations", [[1, 1], [2, 2], [3, 5]])
@@ -451,12 +451,12 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.nightly
     def test_conv_4D(self, params, dilations, pads, strides, bias, ie_device, precision, ir_version,
-                     temp_dir, api_2):
+                     temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, shape=[2, 3, 25, 25], dilations=dilations, pads=pads,
                              strides=strides, bias=bias,
                              ir_version=ir_version), ie_device, precision, ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_autopad[:-1])
     @pytest.mark.parametrize("auto_pad", ['SAME_UPPER', 'SAME_LOWER'])
@@ -464,10 +464,10 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.xfail(reason='autopad dimetions do not agree with framework')
     def test_conv_4D_autopad(self, params, auto_pad, bias, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         self._test(*self.create_net(**params, shape=[2, 3, 25, 25], bias=bias, auto_pad=auto_pad,
                                     ir_version=ir_version), ie_device, precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D_precommit)
     @pytest.mark.parametrize("dilations", [[3, 4, 5]])
@@ -476,12 +476,12 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.precommit
     def test_conv_5D_precommit(self, params, dilations, pads, strides, bias, ie_device, precision,
-                               ir_version, temp_dir, api_2):
+                               ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, shape=[2, 3, 25, 25, 25], dilations=dilations, pads=pads,
                              strides=strides,
                              bias=bias, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.parametrize("dilations", [[1, 1, 1], [2, 2, 2], [3, 4, 5]])
@@ -490,12 +490,12 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.nightly
     def test_conv_5D(self, params, dilations, pads, strides, bias, ie_device, precision, ir_version,
-                     temp_dir, api_2):
+                     temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, shape=[2, 3, 25, 25, 25], dilations=dilations, pads=pads,
                              strides=strides,
                              bias=bias, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D_autopad[:-1])
     @pytest.mark.parametrize("auto_pad", ['SAME_UPPER', 'SAME_LOWER'])
@@ -503,8 +503,8 @@ class TestConv(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.xfail(reason='autopad dimetions do not agree with framework')
     def test_conv_5D_autopad(self, params, auto_pad, bias, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, shape=[2, 3, 25, 25, 25], bias=bias, auto_pad=auto_pad,
                              ir_version=ir_version), ie_device, precision, ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_conv_transpose.py

@@ -184,45 +184,45 @@ class TestConvTranspose(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("auto_pad", ["NOTSET"])
     @pytest.mark.precommit
     def test_conv_transpose_4D_precommit(self, params, bias, ie_device, precision, ir_version,
-                                         auto_pad, temp_dir, api_2):
+                                         auto_pad, temp_dir, use_old_api):
         if ie_device == 'GPU' and 'dilations' in params:
             pytest.xfail('dilations are not supported on GPU')
         self._test(*self.create_conv_transpose(**params, ir_version=ir_version, bias=bias,
                                                auto_pad=auto_pad),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", explicit_pads_tests_4D)
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.parametrize("auto_pad", ["NOTSET"])
     @pytest.mark.nightly
     def test_conv_transpose_4D(self, params, bias, ie_device, precision, ir_version, auto_pad,
-                               temp_dir, api_2):
+                               temp_dir, use_old_api):
         if ie_device == 'GPU' and 'dilations' in params:
             pytest.xfail('dilations are not supported on GPU')
         self._test(*self.create_conv_transpose(**params, ir_version=ir_version, bias=bias,
                                                auto_pad=auto_pad),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", valid_auto_pad_tests_4D)
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.parametrize("auto_pad", ["VALID"])
     @pytest.mark.nightly
     def test_conv_transpose_valid_auto_pad_4D(self, params, bias, ie_device, precision, ir_version,
-                                              auto_pad, temp_dir, api_2):
+                                              auto_pad, temp_dir, use_old_api):
         if ie_device == 'GPU' and 'dilations' in params:
             pytest.xfail('dilations are not supported on GPU')
         self._test(*self.create_conv_transpose(**params, ir_version=ir_version, bias=bias,
                                                auto_pad=auto_pad),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", same_auto_pad_tests_4D)
     @pytest.mark.parametrize("bias", [False, True])
     @pytest.mark.parametrize("auto_pad", ["SAME_UPPER", "SAME_LOWER"])
     @pytest.mark.nightly
     def test_conv_transpose_same_auto_pad_4D(self, params, bias, ie_device, precision, ir_version,
-                                             auto_pad, temp_dir, api_2):
+                                             auto_pad, temp_dir, use_old_api):
         if ie_device == 'GPU' and 'dilations' in params:
             pytest.xfail('dilations are not supported on GPU')
         self._test(*self.create_conv_transpose(**params, ir_version=ir_version, bias=bias,
                                                auto_pad=auto_pad),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_cumsum.py

@@ -253,22 +253,22 @@ class TestCumSum(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("exclusive", [0, 1])
     @pytest.mark.nightly
     def test_cumsum(self, params, reverse, exclusive, ie_device, precision, ir_version, temp_dir,
-                    api_2):
+                    use_old_api):
         if 'axis' not in params:
             pytest.skip('No axis cases fail in ONNX')
         self._test(
             *self.create_net(**params, exclusive=exclusive, reverse=reverse, ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("reverse", [0, 1])
     @pytest.mark.parametrize("exclusive", [0, 1])
     @pytest.mark.nightly
     def test_cumsum_const(self, params, reverse, exclusive, ie_device, precision, ir_version,
-                          temp_dir, api_2):
+                          temp_dir, use_old_api):
         if 'axis' not in params:
             pytest.skip('No axis cases fail in ONNX')
         self._test(*self.create_net_const(**params, precision=precision, exclusive=exclusive,
                                           reverse=reverse,
                                           ir_version=ir_version), ie_device, precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_dequantize_linear.py

@@ -195,31 +195,31 @@ class TestDequantizeLinear(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.xfail(reason='Defualt zero_point fails on onnxruntime')
     def test_quantize_linear_def_zerop_opset10(self, params, ie_device, precision, ir_version,
-                                               temp_dir, api_2):
+                                               temp_dir, use_old_api):
         self._test(*self.create_dequanize_linear(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_quantize_linear_opset10(self, params, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         self._test(*self.create_dequanize_linear(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data + test_data_def_zerop)
     @pytest.mark.nightly
     @pytest.mark.skip(reason='DequantizeLinear-13 is unsupported in MO')
     def test_quantize_linear_opset13(self, params, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         self._test(*self.create_dequanize_linear(**params, opset=13, ir_version=ir_version),
                    ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_axis)
     @pytest.mark.nightly
     @pytest.mark.skip(reason='DequantizeLinear-13 is unsupported in MO')
     def test_quantize_linear_axis_opset13(self, params, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_dequanize_linear(**params, opset=13, ir_version=ir_version),
                    ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_dropout.py

@@ -146,28 +146,28 @@ class TestDropout(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_dropout_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dropout_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, opset=6, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_dropout(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dropout(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_dropout_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dropout_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, opset=6, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_dropout_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dropout_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_elu.py

@@ -175,13 +175,13 @@ class TestElu(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_elu(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_elu(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_elu_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_elu_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_embedding_bag.py

@@ -8,7 +8,6 @@ import pytest
 import torch
 import torch.nn as nn
 from common.layer_test_class import CommonLayerTest, check_ir_version
-
 from unit_tests.utils.graph import build_graph
 
 
@@ -132,6 +131,6 @@ class TestPytorchEmbeddingBag(PytorchLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_pytorch_embedding_bag(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_pytorch_embedding_bag(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params), ie_device, precision, ir_version, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_flatten.py

@@ -184,126 +184,126 @@ class TestFlatten(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
-    def test_flatten_3D(self, params, opset, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_flatten_3D(self, params, opset, ie_device, precision, ir_version, temp_dir, use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_3D_const(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net_const(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
-    def test_flatten_4D(self, params, opset, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_flatten_4D(self, params, opset, ie_device, precision, ir_version, temp_dir, use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_precommit)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.precommit
     def test_flatten_4D_precommit(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                                  api_2):
+                                  use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_precommit)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_4D_const_precommit(self, params, opset, ie_device, precision, ir_version,
-                                        temp_dir, api_2):
+                                        temp_dir, use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net_const(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_4D_const(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net_const(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D_precommit)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_5D_precommit(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                                  api_2):
+                                  use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
-    def test_flatten_5D(self, params, opset, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_flatten_5D(self, params, opset, ie_device, precision, ir_version, temp_dir, use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D_precommit)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_5D_const_precommit(self, params, opset, ie_device, precision, ir_version,
-                                        temp_dir, api_2):
+                                        temp_dir, use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net_const(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.parametrize("opset", [6, 9])
     @pytest.mark.nightly
     def test_flatten_5D_const(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         # negative axis not allowed by onnx spec for flatten-1 and flatten-9
         if params['axis'] < 0:
             self.skip_framework = True
         else:
             self.skip_framework = False
         self._test(*self.create_flatten_net_const(**params, ir_version=ir_version, opset=opset),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_floor.py

@@ -168,13 +168,13 @@ class TestFloor(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_floor(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_floor(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_floor_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_floor_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_fusedgemm.py

@@ -1,12 +1,8 @@
 # Copyright (C) 2018-2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import os
-
 import numpy as np
 import pytest
-import torch
-from common.layer_test_class import CommonLayerTest
 from common.onnx_layer_test_class import OnnxRuntimeLayerTest
 
 
@@ -142,7 +138,7 @@ class TestFusedGemm(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_fusedgemm(self, params, alpha, beta, trans_a, trans_b,
-                  ie_device, precision, opset, ir_version, temp_dir, api_2):
+                       ie_device, precision, opset, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(params['shapeA'], params['shapeB'], params['shapeC'], alpha, beta,
                              trans_a, trans_b,
@@ -150,4 +146,4 @@ class TestFusedGemm(OnnxRuntimeLayerTest):
                              params['activation_beta'], params['activation_gamma'],
                              opset, ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2, custom_eps=1e-2)
+            temp_dir=temp_dir, use_old_api=use_old_api, custom_eps=1e-2)

tests/layer_tests/onnx_tests/test_gather.py

@@ -247,24 +247,24 @@ class TestGather(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_gather(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_gather(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_gather(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_gather(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_gather_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_gather_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     test_data_negative_indices = [
         dict(shape=[10, 12], axis=0, indices=[3, -1, -4], output_shape=[3, 12]),
@@ -278,6 +278,6 @@ class TestGather(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("params", test_data_negative_indices)
     @pytest.mark.nightly
     def test_gather_nightly_negative_indices(self, params, ie_device, precision, ir_version,
-                                             temp_dir, api_2):
+                                             temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_gemm.py

@@ -226,13 +226,13 @@ class TestGemm(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_gemm(self, params, alpha, beta, trans_a, trans_b, ie_device, precision, opset,
-                  ir_version, temp_dir, api_2):
+                  ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(params['shapeA'], params['shapeB'], params['shapeC'], alpha, beta,
                              trans_a,
                              trans_b, precision, opset, ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_bc)
     @pytest.mark.parametrize("alpha", [None, 0.1, 2.0])
@@ -243,13 +243,13 @@ class TestGemm(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_gemm_bc(self, params, alpha, beta, trans_a, trans_b, ie_device, precision, opset,
-                     ir_version, temp_dir, api_2):
+                     ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(params['shapeA'], params['shapeB'], params['shapeC'], alpha, beta,
                              trans_a,
                              trans_b, precision, opset, ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("alpha", [None, 0.1, 2.0])
@@ -259,13 +259,13 @@ class TestGemm(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_gemm_double(self, params, alpha, beta, trans_a, trans_b, ie_device, precision,
-                         ir_version, temp_dir, api_2):
+                         ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_double(params['shapeA'], params['shapeB'], params['shapeC'], alpha,
                                     beta,
                                     trans_a, trans_b, precision, ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_bc)
     @pytest.mark.parametrize("alpha", [None, 0.1, 2.0])
@@ -275,13 +275,13 @@ class TestGemm(OnnxRuntimeLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_gemm_double_bc(self, params, alpha, beta, trans_a, trans_b, ie_device, precision,
-                            ir_version, temp_dir, api_2):
+                            ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_double(params['shapeA'], params['shapeB'], params['shapeC'], alpha,
                                     beta,
                                     trans_a, trans_b, precision, ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
 
 class PytorchLayerTest(CommonLayerTest):
@@ -334,7 +334,7 @@ class TestPytorchMM(PytorchLayerTest):
     # TODO mark as precommit (after successfully passing in nightly)
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_pytorch_mm(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_pytorch_mm(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(precision, **params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_hard_sigmoid.py

@@ -221,20 +221,20 @@ class TestHardSigmoid(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_hard_sigmoid(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_hard_sigmoid(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.nightly
     def test_hard_sigmoid_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_hard_sigmoid_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_hard_sigmoid_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_identity.py

@@ -171,13 +171,13 @@ class TestIdentity(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_identity(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_identity(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_identity_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_identity_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_image_scaler.py

@@ -140,26 +140,26 @@ class TestImageScaler(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     def test_image_scaler_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_image_scaler(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_image_scaler(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     def test_image_scaler_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_image_scaler_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_image_scaler_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_instance_normalization.py

@@ -101,13 +101,13 @@ class TestInstanceNormalization(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_instance_normalization(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_instance_normalization(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_leaky_relu.py

@@ -181,27 +181,27 @@ class TestLeakyRelu(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_leaky_relu_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_leaky_relu_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_leaky_relu(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_leaky_relu(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_leaky_relu_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                        api_2):
+                                        use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_leaky_relu_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_leaky_relu_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_log.py

@@ -171,26 +171,26 @@ class TestLog(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_log_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_log_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_log(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_log(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.nightly
-    def test_log_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_log_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_log_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_log_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_logsoftmax.py

@@ -248,7 +248,7 @@ class TestLog(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_log(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_log(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_loop.py

@@ -273,14 +273,14 @@ class TestLoop(OnnxRuntimeLayerTest):
 
     @pytest.mark.precommit
     @pytest.mark.timeout(250)
-    def test_loop_simple_precommit(self, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_loop_simple_precommit(self, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_loop(), ie_device, precision, ir_version, temp_dir=temp_dir,
-                   infer_timeout=150, api_2=api_2)
+                   infer_timeout=150, use_old_api=use_old_api)
 
     @pytest.mark.precommit
     @pytest.mark.timeout(250)
-    def test_loop_in_loop_simple_precommit(self, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_loop_in_loop_simple_precommit(self, ie_device, precision, ir_version, temp_dir, use_old_api):
         if ie_device == 'GPU':
             pytest.xfail("Program doesn't contain primitive: constant:res/10/M_2 that is input to: loop")
         self._test(*self.create_loop_in_loop(), ie_device, precision, ir_version, temp_dir=temp_dir,
-                   infer_timeout=150, api_2=api_2)
+                   infer_timeout=150, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_lrn.py

@@ -111,27 +111,27 @@ class TestLRN(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_lrn_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_lrn_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         # onnxruntime only supports 4D tensors for LRN
         self.skip_framework = True
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_lrn(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_lrn(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         # onnxruntime only supports 4D tensors for LRN
         self.skip_framework = True
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_lrn_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_lrn_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self.skip_framework = False
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_lstm.py

@@ -144,24 +144,24 @@ class TestLSTM(Caffe2OnnxLayerTest):
     @pytest.mark.parametrize('direction', ["forward", "bidirectional", "reverse"])
     @pytest.mark.parametrize('cell_type', ["LSTM", "GRU", "RNN"])
     def test_lstm_simple_precommit(self, direction, cell_type, ie_device, precision, ir_version,
-                                   temp_dir, api_2):
+                                   temp_dir, use_old_api):
         self._test(*self.create_lstm(direction, cell_type), ie_device, precision, ir_version,
-                   temp_dir=temp_dir, infer_timeout=150, api_2=api_2)
+                   temp_dir=temp_dir, infer_timeout=150, use_old_api=use_old_api)
 
     # LSTM/RNN/GRU Sequence Generation
     @pytest.mark.parametrize('direction', ["forward", "bidirectional", "reverse"])
     @pytest.mark.parametrize('cell_type', ["LSTM", "GRU", "RNN"])
     def test_lstm_sequence_generate(self, direction, cell_type, ie_device, precision, ir_version,
-                                    temp_dir, api_2):
+                                    temp_dir, use_old_api):
         self._test(*self.create_lstm(direction, cell_type), ie_device, precision, ir_version,
                    disabled_transforms='lstm_to_tensor_iterator,gru_and_rnn_to_tensor_iterator',
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     # TODO: add more params for nightly
     @pytest.mark.nightly
     @pytest.mark.parametrize('direction', ["forward", "bidirectional", "reverse"])
     @pytest.mark.parametrize('cell_type', ["LSTM", "GRU", "RNN"])
     def test_lstm_nightly(self, direction, cell_type, ie_device, precision, ir_version, temp_dir,
-                          api_2):
+                          use_old_api):
         self._test(*self.create_lstm(direction, cell_type), ie_device, precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_matmul.py

@@ -167,26 +167,26 @@ class TestMatMul(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_matmul(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_matmul(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_broadcasting)
     @pytest.mark.nightly
-    def test_matmul_bc(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_matmul_bc(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_dual_matmul(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dual_matmul(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_dual_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_broadcasting)
     @pytest.mark.nightly
-    def test_dual_matmul_bc(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_dual_matmul_bc(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_dual_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_mean_variance_normalization.py

@@ -68,6 +68,6 @@ class TestMeanVarianceNormalization(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_mvn(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_mvn(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_neg.py

@@ -80,14 +80,14 @@ class TestNeg(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize('params', test_data_precommit)
     @pytest.mark.precommit
-    def test_neg_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_neg_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_neg(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize('params', test_data)
     @pytest.mark.nightly
-    def test_neg(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_neg(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_neg(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_non_zero.py

@@ -186,13 +186,13 @@ class TestNonZero(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_non_zero(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_non_zero(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_const_data)
     @pytest.mark.nightly
-    def test_non_zero_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_non_zero_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_not.py

@@ -173,21 +173,21 @@ class TestNot(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_not_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_not_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_not(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_not(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_not_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_not_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_or.py

@@ -254,28 +254,28 @@ class TestOr(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_or_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_or_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_or(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_or(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_or_one_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_or_one_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_one_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_or_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_or_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_pad.py

@@ -182,11 +182,11 @@ class TestPad(OnnxRuntimeLayerTest):
                                             ('edge', None)])
     @pytest.mark.nightly
     def test_pad_opset_9(self, params, mode_value, ie_device, precision, ir_version, temp_dir,
-                         api_2):
+                         use_old_api):
         mode, value = mode_value
         self._test(
             *self.create_net(**params, mode=mode, value=value, ir_version=ir_version, opset=9),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.parametrize("mode_value", [(None, None),
@@ -197,10 +197,10 @@ class TestPad(OnnxRuntimeLayerTest):
                                             ('edge', None)])
     @pytest.mark.precommit
     def test_pad_opset_latest_precommit(self, params, mode_value, ie_device, precision, ir_version,
-                                        temp_dir, api_2):
+                                        temp_dir, use_old_api):
         mode, value = mode_value
         self._test(*self.create_net(**params, mode=mode, value=value, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("mode_value", [(None, None),
@@ -211,7 +211,7 @@ class TestPad(OnnxRuntimeLayerTest):
                                             ('edge', None)])
     @pytest.mark.nightly
     def test_pad_opset_latest(self, params, mode_value, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         mode, value = mode_value
         self._test(*self.create_net(**params, mode=mode, value=value, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_pooling.py

@@ -390,110 +390,110 @@ class TestPooling(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("incl_pad", [None, 1])
     @pytest.mark.nightly
     def test_avgpool_opset7(self, params, incl_pad, ie_device, precision, ir_version, temp_dir,
-                            api_2):
+                            use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(
             *self.create_net(**params, op='AveragePool', count_include_pad=incl_pad,
                              ir_version=ir_version, opset=7),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_autopad)
     @pytest.mark.nightly
     def test_avgpool_opset7_autopad(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='AveragePool', ir_version=ir_version, opset=7),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("incl_pad", [None, 1])
     @pytest.mark.parametrize("ceil", [True, False])
     @pytest.mark.nightly
     def test_avgpool_opset10(self, params, incl_pad, ceil, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(
             *self.create_net(**params, op='AveragePool', count_include_pad=incl_pad, ceil=ceil,
                              ir_version=ir_version,
                              opset=10), ie_device, precision, ir_version, temp_dir=temp_dir,
-            api_2=api_2)
+            use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_autopad)
     @pytest.mark.nightly
     def test_avgpool_opset10_autopad(self, params, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='AveragePool', ir_version=ir_version, opset=10),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("st_order", [None, 1])
     @pytest.mark.nightly
     def test_maxpool_opset8(self, params, st_order, ie_device, precision, ir_version, temp_dir,
-                            api_2):
+                            use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(
             *self.create_net(**params, op='MaxPool', storage_order=st_order, ir_version=ir_version,
                              opset=8),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_autopad)
     @pytest.mark.nightly
     def test_maxpool_opset8_autopad(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='MaxPool', ir_version=ir_version, opset=8),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("st_order", [None, 1])
     @pytest.mark.parametrize("ceil", [True, False])
     @pytest.mark.nightly
     def test_maxpool_opset10(self, params, st_order, ceil, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='MaxPool', storage_order=st_order, ceil=ceil,
                                     ir_version=ir_version,
                                     opset=10), ie_device, precision, ir_version, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_autopad_precommit)
     @pytest.mark.precommit
     def test_maxpool_opset10_autopad(self, params, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='MaxPool', ir_version=ir_version, opset=10),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_autopad)
     @pytest.mark.nightly
     def test_maxpool_opset10_autopad(self, params, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_net(**params, op='MaxPool', ir_version=ir_version, opset=10),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", global_test_data)
     @pytest.mark.nightly
-    def test_global_avgpool(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_global_avgpool(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_global_net(**params, op='GlobalAveragePool', ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", global_test_data)
     @pytest.mark.nightly
-    def test_global_maxpool(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_global_maxpool(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         if not len(params['shape']) in [4, 5]:
             pytest.skip("Pooling layer support only 4D and 5D input tensors")
         self._test(*self.create_global_net(**params, op='GlobalMaxPool', ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_prelu.py

@@ -113,52 +113,52 @@ class TestPRelu(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_scalar)
     @pytest.mark.nightly
-    def test_prelu_opset6_scalar(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_prelu_opset6_scalar(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=6, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_shared_channels)
     @pytest.mark.nightly
     def test_prelu_opset6_shared_channels(self, params, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=6, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_scalar)
     @pytest.mark.nightly
-    def test_prelu_opset7_scalar(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_prelu_opset7_scalar(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=7, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_shared_channels)
     @pytest.mark.nightly
     def test_prelu_opset7_shared_channels(self, params, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=7, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_prelu_shared_channels_precommit(self, params, ie_device, precision, ir_version,
-                                             temp_dir, api_2):
+                                             temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_scalar_precommit)
     @pytest.mark.precommit
     def test_prelu_scalar_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_scalar)
     @pytest.mark.nightly
-    def test_prelu_scalar(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_prelu_scalar(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_shared_channels)
     @pytest.mark.nightly
-    def test_prelu_shared_channels(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_prelu_shared_channels(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_reciprocal.py

@@ -148,27 +148,27 @@ class TestReciprocal(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_reciprocal_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reciprocal_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_reciprocal(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reciprocal(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_reciprocal_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                        api_2):
+                                        use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_reciprocal_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reciprocal_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_reduce.py

@@ -125,68 +125,68 @@ class TestReduce(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.precommit
     def test_reduce_max_precommit(self, params, keep_dims, ie_device, precision, ir_version,
-                                  temp_dir, api_2):
+                                  temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMax', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
-    def test_reduce_max(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reduce_max(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMax', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
-    def test_reduce_sum(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reduce_sum(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceSum', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
     def test_reduce_prod(self, params, keep_dims, ie_device, precision, ir_version, temp_dir,
-                         api_2):
+                         use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceProd', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.precommit
     def test_reduce_mean_precommit(self, params, keep_dims, ie_device, precision, ir_version,
-                                   temp_dir, api_2):
+                                   temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMean', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_reduce_mean(self, params, keep_dims, ie_device, precision, ir_version, temp_dir,
-                         api_2):
+                         use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMean', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.precommit
     def test_reduce_min_precommit(self, params, keep_dims, ie_device, precision, ir_version,
-                                  temp_dir, api_2):
+                                  temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMin', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
-    def test_reduce_min(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reduce_min(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reduce(**params, op='ReduceMin', keep_dims=keep_dims,
                                        ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_reduce_lp.py

@@ -221,38 +221,38 @@ class TestReduceL1L2(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("reduce_p", [1, 2])
     @pytest.mark.precommit
     def test_reduce_lp_precommit(self, params, keep_dims, reduce_p, ie_device, precision,
-                                 ir_version, temp_dir, api_2):
+                                 ir_version, temp_dir, use_old_api):
         self._test(*self.create_reduce_lp(**params, keep_dims=keep_dims, reduce_p=reduce_p,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.parametrize("reduce_p", [1, 2])
     @pytest.mark.nightly
     def test_reduce_lp(self, params, keep_dims, reduce_p, ie_device, precision, ir_version,
-                       temp_dir, api_2):
+                       temp_dir, use_old_api):
         self._test(*self.create_reduce_lp(**params, keep_dims=keep_dims, reduce_p=reduce_p,
                                           ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.parametrize("reduce_p", [1, 2])
     @pytest.mark.precommit
     def test_reduce_lp_const_precommit(self, params, keep_dims, reduce_p, ie_device, precision,
-                                       ir_version, temp_dir, api_2):
+                                       ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_reduce_lp_const(**params, keep_dims=keep_dims, reduce_p=reduce_p,
                                          ir_version=ir_version),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.parametrize("reduce_p", [1, 2])
     @pytest.mark.nightly
     def test_reduce_lp_const(self, params, keep_dims, reduce_p, ie_device, precision, ir_version,
-                             temp_dir, api_2):
+                             temp_dir, use_old_api):
         self._test(*self.create_reduce_lp_const(**params, keep_dims=keep_dims, reduce_p=reduce_p,
                                                 ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_relu.py

@@ -172,13 +172,13 @@ class TestRelu(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_relu(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_relu(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_relu_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_relu_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_reshape.py

@@ -231,64 +231,64 @@ class TestReshape(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_5D_precommit)
     @pytest.mark.precommit
-    def test_reshape_5D_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_5D_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D_precommit)
     @pytest.mark.precommit
-    def test_reshape_4D_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_4D_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D_precommit)
     @pytest.mark.precommit
-    def test_reshape_3D_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_3D_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_reshape_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_reshape_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_reshape_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_reshape_const_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_const_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_reshape_const_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_const_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_reshape_const_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reshape_const_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reshape_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_resize.py

@@ -203,10 +203,10 @@ class TestResize(OnnxRuntimeLayerTest):
     ]
 
     @pytest.mark.parametrize("params", test_data)
-    def test_resize(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_resize(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_resize_net(**params, precision=precision, ir_version=ir_version),
                    ie_device, precision, ir_version, custom_eps=2.0e-4, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     test_data_cubic = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -236,14 +236,14 @@ class TestResize(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("nearest_mode", ['round_prefer_floor'])
     def test_resize_combined_cubic(self, params, coordinate_transformation_mode, cubic_coeff_a,
                                    mode,
-                                   nearest_mode, ie_device, precision, ir_version, temp_dir, api_2):
+                                   nearest_mode, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
                    ie_device, precision, ir_version, custom_eps=2.6e-2, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     test_data_nearest = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -267,13 +267,13 @@ class TestResize(OnnxRuntimeLayerTest):
     def test_resize_combined_nearest(self, params, coordinate_transformation_mode, cubic_coeff_a,
                                      mode,
                                      nearest_mode, ie_device, precision, ir_version, temp_dir,
-                                     api_2):
+                                     use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     test_data_linear = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -304,14 +304,14 @@ class TestResize(OnnxRuntimeLayerTest):
     def test_resize_combined_linear(self, params, coordinate_transformation_mode, cubic_coeff_a,
                                     mode,
                                     nearest_mode, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
                    ie_device, precision, ir_version, custom_eps=2.0e-2, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     test_data_sizes = [
         dict(input_shape=[1, 1, 4, 4], output_shape=[1, 1, 3, 3],
@@ -357,9 +357,9 @@ class TestResize(OnnxRuntimeLayerTest):
     ]
 
     @pytest.mark.parametrize("params", test_data_sizes)
-    def test_resize_sizes(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_resize_sizes(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_resize_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     test_data_sizes_cubic = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -390,14 +390,14 @@ class TestResize(OnnxRuntimeLayerTest):
     def test_resize_combined_sizes_cubic(self, params, coordinate_transformation_mode,
                                          cubic_coeff_a, mode,
                                          nearest_mode, ie_device, precision, ir_version, temp_dir,
-                                         api_2):
+                                         use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
                    ie_device, precision, ir_version, custom_eps=2.6e-2, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     test_data_sizes_nearest = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -445,13 +445,13 @@ class TestResize(OnnxRuntimeLayerTest):
     def test_resize_combined_sizes_nearest(self, params, coordinate_transformation_mode,
                                            cubic_coeff_a, mode,
                                            nearest_mode, ie_device, precision, ir_version, temp_dir,
-                                           api_2):
+                                           use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     test_data_sizes_linear = [
         dict(input_shape=[1, 3, 100, 200], output_shape=[1, 3, 350, 150],
@@ -482,14 +482,14 @@ class TestResize(OnnxRuntimeLayerTest):
     def test_resize_combined_sizes_linear(self, params, coordinate_transformation_mode,
                                           cubic_coeff_a, mode,
                                           nearest_mode, ie_device, precision, ir_version, temp_dir,
-                                          api_2):
+                                          use_old_api):
         self._test(*self.create_resize_net(**params,
                                            coordinate_transformation_mode=coordinate_transformation_mode,
                                            cubic_coeff_a=cubic_coeff_a, mode=mode,
                                            nearest_mode=nearest_mode,
                                            precision=precision, ir_version=ir_version),
                    ie_device, precision, ir_version, custom_eps=2.0e-2, temp_dir=temp_dir,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
 
 def create_ref_net_in_sizes_mode(precision, input_shape, output_shape, sizes_value, scales_value,

tests/layer_tests/onnx_tests/test_roi_align.py

@@ -1,11 +1,10 @@
 # Copyright (C) 2018-2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import pytest
 import numpy as np
+import pytest
 from common.layer_test_class import check_ir_version
 from common.onnx_layer_test_class import OnnxRuntimeLayerTest
-
 from unit_tests.utils.graph import build_graph
 
 
@@ -134,10 +133,10 @@ class TestROIAlign(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_roi_alignv10(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_roi_alignv10(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         # TODO: ticket for investigating GPU failures: CVS-86300
         if ie_device != "GPU":
             self._test(*self.create_net(**params, ir_version=ir_version, onnx_version=10), ie_device, precision,
                        ir_version,
-                        temp_dir=temp_dir, api_2=api_2,
+                       temp_dir=temp_dir, use_old_api=use_old_api,
                        use_legacy_frontend=True)

tests/layer_tests/onnx_tests/test_scale.py

@@ -133,13 +133,13 @@ class TestScale(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_scale(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_scale(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_scale_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_scale_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_scatter.py

@@ -113,10 +113,10 @@ class TestScatter(TestScatters):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_scatter(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_scatter(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
 
 class TestScatterElements(TestScatters):
@@ -124,7 +124,7 @@ class TestScatterElements(TestScatters):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_scatter_elements(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_scatter_elements(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_sigmoid.py

@@ -179,20 +179,20 @@ class TestSigmoid(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_sigmoid_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sigmoid_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sigmoid(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sigmoid(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sigmoid_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sigmoid_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_sign.py

@@ -166,13 +166,13 @@ class TestSign(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sign(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sign(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sign_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sign_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_slice.py

@@ -371,42 +371,42 @@ class TestSlice(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data_no_steps)
     @pytest.mark.nightly
-    def test_slice_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, opset=6, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_no_steps)
     @pytest.mark.nightly
-    def test_slice_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, opset=6, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_no_steps + test_data_with_steps)
     @pytest.mark.nightly
-    def test_slice_opset10(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_opset10(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, opset=10, ir_version=ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_no_steps + test_data_with_steps)
     @pytest.mark.nightly
-    def test_slice_const_opset10(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_const_opset10(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, opset=10, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_no_steps + test_data_with_steps)
     @pytest.mark.nightly
-    def test_slice_opset11(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_opset11(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, opset=11, ir_version=ir_version), ie_device, precision,
             ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_no_steps + test_data_with_steps)
     @pytest.mark.nightly
-    def test_slice_const_opset11(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_slice_const_opset11(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, opset=11, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_softmax.py

@@ -166,7 +166,7 @@ class TestSoftmax(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_softmax(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_softmax(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_softplus.py

@@ -171,13 +171,13 @@ class TestSoftplus(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_softplus(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_softplus(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_softplus_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_softplus_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_softsign.py

@@ -172,14 +172,14 @@ class TestSoftsign(Caffe2OnnxLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_softsign(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_softsign(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_softsign_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_softsign_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_split_concat.py

@@ -261,42 +261,42 @@ class TestSplitConcat(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_split_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_concat_net(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_split_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_concat_net(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_split_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_concat_net(**params, ir_version=ir_version), ie_device,
-                   precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_split_3D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_3D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_split_concat_net_const(**params, ir_version=ir_version), ie_device,
-            precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_split_4D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_4D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_split_concat_net_const(**params, ir_version=ir_version), ie_device,
-            precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_split_5D_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_5D_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_split_concat_net_const(**params, ir_version=ir_version), ie_device,
-            precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
 
 class TestSplit(Caffe2OnnxLayerTest):
@@ -543,35 +543,35 @@ class TestSplit(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_split_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_net(**params, ir_version=ir_version), ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_split_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_net(**params, ir_version=ir_version), ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_split_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_net(**params, ir_version=ir_version), ie_device, precision,
-                   ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_multiple_out)
-    def test_split_outputs_order(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_split_outputs_order(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_split_net_ordered_outputs(**params, ir_version=ir_version),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   output_names=params['output_names'], api_2=api_2)
+                   output_names=params['output_names'], use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_multiple_out_with_add)
     def test_split_outputs_order_multiple_connection_before_result_case(self, params, ie_device,
                                                                         precision, ir_version,
-                                                                        temp_dir, api_2):
+                                                                        temp_dir, use_old_api):
         self._test(*self.create_split_net_ordered_outputs_with_add(**params, ir_version=ir_version),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   output_names=params['output_names'], api_2=api_2)
+                   output_names=params['output_names'], use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_multiple_out_with_identity)
     def test_split_outputs_order_multiple_tensors_before_result_case(self,
@@ -579,8 +579,8 @@ class TestSplit(Caffe2OnnxLayerTest):
                                                                      ie_device,
                                                                      precision,
                                                                      ir_version,
-                                                                     temp_dir, api_2):
+                                                                     temp_dir, use_old_api):
         self._test(*self.create_split_net_ordered_outputs_multiple_tensor_names(**params,
                                                                                 ir_version=ir_version),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   output_names=params['output_names'], api_2=api_2)
+                   output_names=params['output_names'], use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_sqrt.py

@@ -176,13 +176,13 @@ class TestSqrt(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sqrt(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sqrt(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sqrt_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sqrt_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_squeeze.py

@@ -175,42 +175,42 @@ class TestSqueeze(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_squeeze_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_squeeze_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_squeeze_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_squeeze_const_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_const_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_squeeze_const_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_const_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_squeeze_const_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_squeeze_const_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_squeeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_sum.py

@@ -285,57 +285,57 @@ class TestSum(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sum_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, opset=6, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_sum_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, precision=precision, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sum(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net(**params, precision=precision, ir_version=ir_version), ie_device,
             precision, ir_version,
-            temp_dir=temp_dir, api_2=api_2)
+            temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", const_test_data)
     @pytest.mark.nightly
-    def test_sum_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum_const_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_const_net(**params, opset=6, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", const_test_data_precommit)
     @pytest.mark.precommit
-    def test_sum_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_const_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", const_test_data)
     @pytest.mark.nightly
-    def test_sum_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sum_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_const_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", const_test_data_broadcasting_precommit)
     @pytest.mark.precommit
     def test_sum_const_broadcasting_precommit(self, params, ie_device, precision, ir_version,
-                                              temp_dir, api_2):
+                                              temp_dir, use_old_api):
         self._test(*self.create_const_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", const_test_data_broadcasting)
     @pytest.mark.nightly
     def test_sum_const_broadcasting(self, params, ie_device, precision, ir_version, temp_dir,
-                                    api_2):
+                                    use_old_api):
         self._test(*self.create_const_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_topk.py

@@ -147,25 +147,25 @@ class TestTopK(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_topk_opset6(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_topk_opset6(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, opset=6, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_topk_opset10(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_topk_opset10(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, opset=10, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("largest", [1, 0, None])
     @pytest.mark.parametrize("sorted", [1, 0, None])
     @pytest.mark.nightly
     def test_topk_opset11(self, params, ie_device, precision, ir_version, largest, sorted, temp_dir,
-                          api_2):
+                          use_old_api):
         self._test(*self.create_net(**params, largest=largest, sorted=sorted,
                                     opset=11, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_transpose.py

@@ -155,29 +155,29 @@ class TestTranspose(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_transpose_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_transpose_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_transpose(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_transpose(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.nightly
     def test_transpose_const_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                       api_2):
+                                       use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_transpose_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_transpose_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_trigonometry.py

@@ -179,140 +179,140 @@ class TestTrigonomery(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sin(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sin(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Sin'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sinh(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sinh(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Sinh'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_asin(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_asin(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Asin'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_cos_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cos_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Cos'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_cos(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cos(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Cos'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_cosh(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cosh(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Cosh'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_acos(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_acos(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Acos'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_tan(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_tan(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Tan'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_tanh(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_tanh(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Tanh'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_atan(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_atan(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version, op='Atan'), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sin_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sin_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Sin'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_sinh_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_sinh_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Sinh'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_asin_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_asin_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Asin'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
-    def test_cos_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cos_const_precommit(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Cos'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_cos_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cos_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Cos'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_cosh_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_cosh_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Cosh'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_acos_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_acos_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Acos'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_tan_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_tan_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Tan'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_tanh_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_tanh_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Tanh'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_atan_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_atan_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(
             *self.create_net_const(**params, ir_version=ir_version, precision=precision, op='Atan'),
-            ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+            ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_unsqueeze.py

@@ -175,42 +175,42 @@ class TestUnsqueeze(Caffe2OnnxLayerTest):
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_unsqueeze_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_unsqueeze_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_unsqueeze_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
-    def test_unsqueeze_const_5D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_const_5D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
-    def test_unsqueeze_const_4D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_const_4D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
-    def test_unsqueeze_const_3D(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_unsqueeze_const_3D(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_unsqueeze_net_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_upsample.py

@@ -95,9 +95,9 @@ class TestUpsample(OnnxRuntimeLayerTest):
     @pytest.mark.parametrize("opset", [7, 9])
     @pytest.mark.nightly
     def test_upsample_nearest(self, params, mode, opset, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         self._test(*self.create_net(**params, mode=mode, opset=opset, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("opset", [7, 9])
@@ -105,9 +105,9 @@ class TestUpsample(OnnxRuntimeLayerTest):
     @pytest.mark.xfail(
         reason='Both onnxruntime and caffe2 calculate linear upsampling differently from IE')
     def test_upsample_linear(self, params, opset, ie_device, precision, ir_version, temp_dir,
-                             api_2):
+                             use_old_api):
         self._test(*self.create_net(**params, mode='linear', opset=opset, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
 
 class PytorchLayerTest(CommonLayerTest):
@@ -176,20 +176,20 @@ class TestPytorchUpsample(PytorchLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.parametrize("mode", [None, 'nearest'])
     def test_pytorch_upsample_precommit(self, params, mode, ie_device, precision, ir_version,
-                                        temp_dir, api_2):
+                                        temp_dir, use_old_api):
         if ie_device == 'GPU':
             pytest.skip('Linear upsampling not supported on GPU')
         self._test(*self.create_net(**params, mode=mode, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("mode", [None, 'nearest', 'bilinear'])
     @pytest.mark.nightly
     def test_pytorch_upsample(self, params, mode, ie_device, precision, ir_version, temp_dir,
-                              api_2):
+                              use_old_api):
         if ie_device == 'GPU' and mode == 'bilinear':
             pytest.skip('Linear upsampling not supported on GPU')
         self._test(*self.create_net(**params, mode=mode, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_where.py

@@ -94,7 +94,7 @@ class TestWhere(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_where(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_where(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/onnx_tests/test_xor.py

@@ -251,21 +251,21 @@ class TestXor(OnnxRuntimeLayerTest):
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_xor(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_xor(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_xor_one_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_xor_one_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_one_const(**params, ir_version=ir_version), ie_device,
                    precision, ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
-    def test_xor_const(self, params, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_xor_const(self, params, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_net_const(**params, ir_version=ir_version), ie_device, precision,
                    ir_version,
-                   temp_dir=temp_dir, api_2=api_2)
+                   temp_dir=temp_dir, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/conftest.py

@@ -2,15 +2,13 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import inspect
-import os
-import sys
 import logging as log
+import os
 from pathlib import Path
 
 import pytest
 from common.layer_test_class import get_params
-
-from common.utils.common_utils import rename_ov_lib
+from common.utils.common_utils import copy_files_by_pattern
 
 
 def pytest_generate_tests(metafunc):
@@ -21,42 +19,20 @@ def pytest_generate_tests(metafunc):
 
 @pytest.fixture(scope='session', autouse=True)
 def rename_tf_fe_libs(request):
-    # code before 'yield' statement is equal to 'set_up' function
+    if os.getenv('OV_FRONTEND_PATH'):
+        # use this env variable to define path to your specific libs
+        openvino_lib_path = Path(os.getenv('OV_FRONTEND_PATH'))
+    else:
         try:
             import openvino.runtime as rt
+            # path below is built considering the use of wheels
+            openvino_lib_path = Path(rt.__file__).parent.parent / 'libs'
         except ImportError as err:
-        raise Exception("Please set PYTHONPATH to OpenVINO Python") from err
+            raise Exception("Please set PYTHONPATH to OpenVINO Python or install wheel package "
+                            "or use OV_FRONTEND_PATH env variable") from err
 
-    openvino_lib_path = Path(rt.__file__).parent.parent.parent.parent.parent
-
-    if sys.platform == 'win32':
-        tf_fe_lib_names = [('openvino_tensorflow_fe.dll', 'openvino_tensorflow_frontend.dll'),
-                           ('openvino_tensorflow_fe.lib', 'openvino_tensorflow_frontend.lib'),
-                           ('openvino_tensorflow_fe.exp', 'openvino_tensorflow_frontend.exp')]
-    else:
-        tf_fe_lib_names = [('libopenvino_tensorflow_fe.so', 'libopenvino_tensorflow_frontend.so')]
+    tf_fe_lib_names = ['libopenvino_tensorflow_fe', 'libopenvino_tensorflow_frontend']
 
     if request.config.getoption('use_new_frontend'):
         log.info('Using new frontend...')
-
-        # check if all required files already have new names
-        if all([file_pair[1] in os.listdir(openvino_lib_path) for file_pair in tf_fe_lib_names]):
-            log.info('TF FE libraries already have new names, no renaming will be done')
-        else:
-            rename_ov_lib(tf_fe_lib_names, openvino_lib_path)
-
-    # code after 'yield' statement is equal to 'tear_down' function
-    yield
-
-    # check if all required files already have old names
-    if all([file_pair[0] in os.listdir(openvino_lib_path) for file_pair in tf_fe_lib_names]):
-        log.info('TF FE libraries already have old names, no renaming will be done')
-    else:
-        if sys.platform == 'win32':
-            tf_fe_lib_names = [('openvino_tensorflow_frontend.dll', 'openvino_tensorflow_fe.dll'),
-                               ('openvino_tensorflow_frontend.lib', 'openvino_tensorflow_fe.lib'),
-                               ('openvino_tensorflow_frontend.exp', 'openvino_tensorflow_fe.exp')]
-        else:
-            tf_fe_lib_names = [('libopenvino_tensorflow_frontend.so', 'libopenvino_tensorflow_fe.so')]
-        rename_ov_lib(tf_fe_lib_names, openvino_lib_path)
-
+        copy_files_by_pattern(openvino_lib_path, tf_fe_lib_names[0], tf_fe_lib_names[1])

tests/layer_tests/tensorflow_tests/test_tf_Add.py

@@ -70,11 +70,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_add_placeholder_const_1D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [
         # Power
@@ -91,11 +91,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_add_placeholder_const_2D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         # Power
@@ -115,11 +115,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_add_placeholder_const_3D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         # Power
@@ -137,11 +137,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_add_placeholder_const_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         # Power
@@ -159,11 +159,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_add_placeholder_const_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version=ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     ###############################################################################################
     #                                                                                             #
@@ -179,11 +179,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_1D)
     @pytest.mark.nightly
     def test_add_placeholder_const_broadcast_1D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version=ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_2D = [
         # Power
@@ -202,11 +202,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_2D)
     @pytest.mark.nightly
     def test_add_placeholder_const_broadcast_2D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version=ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_3D = [
         # Power
@@ -234,11 +234,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_3D)
     @pytest.mark.nightly
     def test_add_placeholder_const_broadcast_3D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version=ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_4D = [
         # Power
@@ -267,11 +267,11 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_add_placeholder_const_broadcast_4D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version=ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_5D = [
         # Power
@@ -298,10 +298,10 @@ class TestAdd(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_add_placeholder_const_broadcast_5D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         # we do not perform transpose in the test in case of new frontend
         self._test(*self.create_add_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision,
                    ir_version=ir_version, temp_dir=temp_dir, use_new_frontend=use_new_frontend,
-                   api_2=api_2)
+                   use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_BatchToSpace.py

@@ -63,11 +63,11 @@ class TestBatchToSpace(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_batch_to_space_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         self._test(*self.create_batch_to_space_net(**params, ir_version=ir_version,
                                                    use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         dict(in_shape=[72, 2, 1, 4, 2], block_shape_value=[3, 4, 2],
@@ -81,8 +81,8 @@ class TestBatchToSpace(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_batch_to_space_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         self._test(*self.create_batch_to_space_net(**params, ir_version=ir_version,
                                                    use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_BiasAdd.py

@@ -119,20 +119,20 @@ class TestBiasAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_bias_add_placeholder_const_2D(self, params, ie_device, precision, ir_version, temp_dir,
-                                           use_new_frontend, api_2):
+                                           use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_placeholder_const_net(**params, ir_version=ir_version,
                                                                use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_bias_add_2_consts_2D(self, params, ie_device, precision, ir_version, temp_dir,
-                                  use_new_frontend, api_2):
+                                  use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_2_consts_net(**params, ir_version=ir_version,
                                                       use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         pytest.param(dict(shape=[1, 1, 224]), marks=pytest.mark.xfail(reason="*-19053")),
@@ -142,20 +142,20 @@ class TestBiasAdd(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_bias_add_placeholder_const_3D(self, params, ie_device, precision, ir_version, temp_dir,
-                                           use_new_frontend, api_2):
+                                           use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_placeholder_const_net(**params, ir_version=ir_version,
                                                                use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_bias_add_2_consts_3D(self, params, ie_device, precision, ir_version, temp_dir,
-                                  use_new_frontend, api_2):
+                                  use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_2_consts_net(**params, ir_version=ir_version,
                                                       use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         dict(shape=[1, 1, 100, 224]),
@@ -166,20 +166,20 @@ class TestBiasAdd(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_bias_add_placeholder_const_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                                           use_new_frontend, api_2):
+                                           use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_placeholder_const_net(**params, ir_version=ir_version,
                                                                use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_bias_add_2_consts_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                                  use_new_frontend, api_2):
+                                  use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_2_consts_net(**params, ir_version=ir_version,
                                                       use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         dict(shape=[1, 1, 50, 100, 224]),
@@ -190,17 +190,17 @@ class TestBiasAdd(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_bias_add_placeholder_const_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                                           use_new_frontend, api_2):
+                                           use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_placeholder_const_net(**params, ir_version=ir_version,
                                                                use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_bias_add_2_consts_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                                  use_new_frontend, api_2):
+                                  use_new_frontend, use_old_api):
         self._test(*self.create_bias_add_2_consts_net(**params, ir_version=ir_version,
                                                       use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py

@@ -124,7 +124,7 @@ class TestBinaryOps(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_binary_op(self, params, ie_device, precision, ir_version, temp_dir, op_type,
-                       use_new_frontend, api_2):
+                       use_new_frontend, use_old_api):
         if ie_device == 'GPU' and precision == "FP16":
             pytest.skip("BinaryOps tests temporary skipped on GPU with FP16 precision."
                         "Several tests don't pass accuracy checks.")
@@ -132,4 +132,4 @@ class TestBinaryOps(CommonTFLayerTest):
             *self.create_add_placeholder_const_net(**params, ir_version=ir_version, op_type=op_type,
                                                    use_new_frontend=use_new_frontend), ie_device,
             precision,
-            ir_version, temp_dir=temp_dir, use_new_frontend=use_new_frontend, api_2=api_2)
+            ir_version, temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py

@@ -68,11 +68,11 @@ class TestBucketize(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_float32)
     @pytest.mark.nightly
     def test_bucketize_float32(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         self._test(*self.create_bucketize_net(**params, ir_version=ir_version,
                                               use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_int32 = [
         dict(input_shape=[5], input_type=tf.int32, boundaries_size=1),
@@ -85,8 +85,8 @@ class TestBucketize(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_int32)
     @pytest.mark.nightly
     def test_bucketize_int32(self, params, ie_device, precision, ir_version, temp_dir,
-                             use_new_frontend, api_2):
+                             use_new_frontend, use_old_api):
         self._test(*self.create_bucketize_net(**params, ir_version=ir_version,
                                               use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Concat.py

@@ -61,11 +61,11 @@ class TestConcat(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_concat_1D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [dict(shape=[1, 224], axis=0),
                     dict(shape=[1, 224], axis=-1)]
@@ -73,11 +73,11 @@ class TestConcat(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_concat_2D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         pytest.param(dict(shape=[1, 3, 224], axis=0), marks=pytest.mark.xfail(reason="*-19053")),
@@ -87,11 +87,11 @@ class TestConcat(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_concat_3D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [dict(shape=[1, 3, 100, 224], axis=0),
                     dict(shape=[1, 3, 100, 224], axis=-1),
@@ -101,11 +101,11 @@ class TestConcat(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_concat_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [dict(shape=[1, 3, 50, 100, 224], axis=0),
                     dict(shape=[1, 3, 50, 100, 224], axis=-1),
@@ -114,8 +114,8 @@ class TestConcat(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_concat_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_concat_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Eltwise.py

@@ -63,11 +63,11 @@ class TestEltwise(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_eltwise(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_eltwise_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = []
     for operation in ['sum', 'max', 'mul']:
@@ -76,10 +76,10 @@ class TestEltwise(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.precommit
     def test_eltwise_5D_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                  use_new_frontend, api_2):
+                                  use_new_frontend, use_old_api):
         if ie_device == 'GPU':
             pytest.skip("5D tensors is not supported on GPU")
         self._test(*self.create_eltwise_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Eye.py

@@ -5,7 +5,6 @@ import numpy as np
 import pytest
 import tensorflow as tf
 from common.tf_layer_test_class import CommonTFLayerTest
-from common.utils.tf_utils import permute_nchw_to_nhwc
 
 
 class TestTFEye(CommonTFLayerTest):
@@ -55,10 +54,10 @@ class TestTFEye(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_tf_eye(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2=True):
+                    use_old_api=True):
         if ie_device == 'GPU':
             pytest.skip("Roll is not supported on GPU")
         self._test(*self.create_tf_eye_net(**params), ie_device,
                    precision,
                    temp_dir=temp_dir, ir_version=ir_version, use_new_frontend=use_new_frontend,
-                   api_2=api_2, **params)
+                   use_old_api=use_old_api, **params)

tests/layer_tests/tensorflow_tests/test_tf_FakeQuantize.py

@@ -140,9 +140,9 @@ class TestFakeQuantize(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_fake_quantize(self, params, ie_device, precision, ir_version, temp_dir,
-                           use_new_frontend, api_2):
+                           use_new_frontend, use_old_api):
         self._test(*self.create_fake_quantize_net(**params, ir_version=ir_version,
                                                   use_new_frontend=use_new_frontend), ie_device,
                    precision, ir_version,
                    kwargs_to_prepare_input=params, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_GRUBlockCell.py

@@ -1,11 +1,11 @@
 # Copyright (C) 2018-2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import pytest
 import numpy as np
-
+import pytest
 from common.tf_layer_test_class import CommonTFLayerTest
 
+
 class TestTFGRUBlockCell(CommonTFLayerTest):
     def _prepare_input(self, inputs_dict):
         for input in inputs_dict.keys():
@@ -65,9 +65,9 @@ class TestTFGRUBlockCell(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_tf_gru_block_cell(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         if ie_device == 'GPU':
             pytest.skip("Skip TF GRUBlockCell test on GPU")
         self._test(*self.create_tf_gru_block_cell(**params),
                    ie_device, precision, temp_dir=temp_dir, ir_version=ir_version,
-                   use_new_frontend=use_new_frontend, api_2=api_2, custom_eps=1e-3, **params)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api, custom_eps=1e-3, **params)

tests/layer_tests/tensorflow_tests/test_tf_Gather.py

@@ -38,11 +38,11 @@ class TestGather(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_gather(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                    api_2):
+                    use_old_api):
         self._test(*self.create_gather_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_nightly = [
         dict(data_shape=[2, 3], axis=1, indices=[0, 2], batch_dims=0),
@@ -63,7 +63,7 @@ class TestGather(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_nightly)
     @pytest.mark.nightly
     def test_gather_nightly(self, params, ie_device, precision, ir_version, temp_dir,
-                            use_new_frontend, api_2):
+                            use_new_frontend, use_old_api):
         self._test(*self.create_gather_net(**params, use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Identity.py

@@ -69,11 +69,11 @@ class TestIdentity(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_identity_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                use_new_frontend, api_2):
+                                use_new_frontend, use_old_api):
         self._test(*self.create_identity_net(**params, ir_version=ir_version,
                                              use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data = [dict(shape=[1]),
                  dict(shape=[1, 224]),
@@ -84,8 +84,8 @@ class TestIdentity(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_identity(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                      api_2):
+                      use_old_api):
         self._test(*self.create_identity_net(**params, ir_version=ir_version,
                                              use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_LogSoftmax.py

@@ -8,7 +8,6 @@ import pytest
 from common.layer_test_class import check_ir_version
 from common.tf_layer_test_class import CommonTFLayerTest
 from common.utils.tf_utils import permute_nchw_to_nhwc
-
 from openvino.tools.mo.front.common.partial_infer.utils import int64_array
 from unit_tests.utils.graph import build_graph
 
@@ -124,11 +123,11 @@ class TestLogSoftmax(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_log_softmax_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                   use_new_frontend, api_2):
+                                   use_new_frontend, use_old_api):
         self._test(*self.create_log_softmax_net(**params, ir_version=ir_version,
                                                 use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data = [dict(shape=[1], reduction_axis=-1),
                  dict(shape=[2, 5], reduction_axis=-1),
@@ -138,8 +137,8 @@ class TestLogSoftmax(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_log_softmax(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                         api_2):
+                         use_old_api):
         self._test(*self.create_log_softmax_net(**params, ir_version=ir_version,
                                                 use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Mul.py

@@ -69,11 +69,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_1D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [
         # Power
@@ -90,11 +90,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_2D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         # Power
@@ -114,11 +114,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_3D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         # Power
@@ -135,11 +135,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         # Power
@@ -157,11 +157,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                                      use_new_frontend, api_2):
+                                      use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     ###############################################################################################
     #                                                                                             #
@@ -176,11 +176,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_1D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_broadcast_1D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_2D = [
         # Power
@@ -199,11 +199,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_2D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_broadcast_2D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_3D = [
         # Power
@@ -232,11 +232,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_3D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_broadcast_3D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_4D = [
         # Power
@@ -265,11 +265,11 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_mul_placeholder_const_broadcast_4D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_5D = [
         # Power
@@ -295,8 +295,8 @@ class TestMul(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_5D)
     @pytest.mark.nightly
     def test_mul_placeholder_const_broadcast_5D(self, params, ie_device, precision, ir_version,
-                                                temp_dir, use_new_frontend, api_2):
+                                                temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_mul_placeholder_const_net(**params, ir_version=ir_version,
                                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_NonMaxSupression.py

@@ -12,7 +12,7 @@ class TestNonMaxSupression(CommonTFLayerTest):
 
     # overload inputs generation to suit NMS use case
     def _prepare_input(self, inputs_dict):
-        channel = ':0' if self.api_2 else ''
+        channel = ':0' if self.use_old_api or not self.use_new_frontend else ''
         input_data = {}
         for input in inputs_dict.keys():
             input_data[input + channel] = np.random.uniform(low=0, high=1,
@@ -83,22 +83,22 @@ class TestNonMaxSupression(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_NonMaxSupression(self, test_params, ie_device, precision, ir_version, temp_dir,
-                              use_new_frontend, api_2):
+                              use_new_frontend, use_old_api):
         if ie_device == 'GPU':
             pytest.skip("Skip TF NonMaxSuppresion test on GPU")
-        self.api_2 = api_2
+        self.use_old_api = use_old_api
         self._test(*self.create_nms_net(test_params), ie_device, precision,
                    ir_version, temp_dir=temp_dir, use_new_frontend=use_new_frontend,
-                   api_2=api_2)
+                   use_old_api=use_old_api)
 
     @pytest.mark.parametrize("test_params", test_params)
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_NonMaxSupressionWithScores(self, test_params, ie_device, precision, ir_version, temp_dir,
-                                        use_new_frontend, api_2):
+                                        use_new_frontend, use_old_api):
         if ie_device == 'GPU':
             pytest.skip("Skip TF NonMaxSuppresionWithScores test on GPU")
-        self.api_2 = api_2
+        self.use_old_api = use_old_api
         self._test(*self.create_nms_net(test_params, with_scores=True), ie_device, precision,
                    ir_version, temp_dir=temp_dir, use_new_frontend=use_new_frontend,
-                   api_2=api_2)
+                   use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_NormalizeL2.py

@@ -156,11 +156,11 @@ class TestNormalizeL2(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_fusable_precommit)
     @pytest.mark.precommit
     def test_NormalizeL2_fusable_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                                           use_new_frontend, api_2):
+                                           use_new_frontend, use_old_api):
         self._test(*self.create_normalize_l2_net_fusable(**params, ir_version=ir_version,
                                                          use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_non_fusable_precommit = [
         pytest.param(dict(shape=[2, 3, 5], axes=[0, 1, 2], output_axes=[0, 1, 2]),
@@ -174,11 +174,11 @@ class TestNormalizeL2(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_non_fusable_precommit)
     @pytest.mark.precommit
     def test_NormalizeL2_non_fusable_precommit(self, params, ie_device, precision, ir_version,
-                                               temp_dir, use_new_frontend, api_2):
+                                               temp_dir, use_new_frontend, use_old_api):
         self._test(*self.create_normalize_l2_net_non_fusable(**params, ir_version=ir_version,
                                                              use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version,
-                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, api_2=api_2)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_fusable = [
         dict(shape=[5, 6], axes=[1], output_axes=[1]),
@@ -192,11 +192,11 @@ class TestNormalizeL2(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_fusable)
     @pytest.mark.nightly
     def test_NormalizeL2_fusable(self, params, ie_device, precision, ir_version, temp_dir,
-                                 use_new_frontend, api_2):
+                                 use_new_frontend, use_old_api):
         self._test(*self.create_normalize_l2_net_fusable(**params, ir_version=ir_version,
                                                          use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_non_fusable = [
         dict(shape=[5], axes=[0], output_axes=[0]),
@@ -218,8 +218,8 @@ class TestNormalizeL2(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_non_fusable)
     @pytest.mark.nightly
     def test_NormalizeL2_non_fusable(self, params, ie_device, precision, ir_version, temp_dir,
-                                     use_new_frontend, api_2):
+                                     use_new_frontend, use_old_api):
         self._test(*self.create_normalize_l2_net_non_fusable(**params, ir_version=ir_version,
                                                              use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version,
-                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, api_2=api_2)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_OneHot.py

@@ -64,11 +64,11 @@ class TestOneHot(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_OneHot_1D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_one_hot_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [
         dict(shape=[5, 6], depth=7, on_value=None, off_value=None, axis=None),
@@ -86,11 +86,11 @@ class TestOneHot(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_OneHot_2D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_one_hot_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         dict(shape=[5, 6, 7], depth=8, on_value=None, off_value=None, axis=None),
@@ -109,11 +109,11 @@ class TestOneHot(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_OneHot_3D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_one_hot_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         dict(shape=[5, 6, 7, 8], depth=9, on_value=None, off_value=None, axis=None),
@@ -134,11 +134,11 @@ class TestOneHot(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_OneHot_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_one_hot_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         dict(shape=[4, 5, 6, 7, 8], depth=9, on_value=None, off_value=None, axis=None),
@@ -159,8 +159,8 @@ class TestOneHot(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_OneHot_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_one_hot_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Pooling.py

@@ -178,11 +178,11 @@ class TestPooling(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_pool_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_pooling_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = []
     for method in ['max', 'avg']:
@@ -256,10 +256,10 @@ class TestPooling(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_pool_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         if ie_device == 'GPU':
             pytest.skip("5D tensors is not supported on GPU")
         self._test(*self.create_pooling_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_RandomUniform.py

@@ -101,11 +101,11 @@ class TestTFRandomUniform(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_tf_random_uniform(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         if ie_device == 'GPU':
             pytest.skip("RandomUniform is not supported on GPU")
         self._test(
             *self.create_tf_random_uniform_net(**params, precision=precision, ir_version=ir_version,
                                                use_new_frontend=use_new_frontend), ie_device,
             precision, temp_dir=temp_dir, ir_version=ir_version, use_new_frontend=use_new_frontend,
-            api_2=api_2, **params)
+            use_old_api=use_old_api, **params)

tests/layer_tests/tensorflow_tests/test_tf_ReLU6.py

@@ -69,11 +69,11 @@ class TestReLU6(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_relu6_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                             use_new_frontend, api_2):
+                             use_new_frontend, use_old_api):
         self._test(*self.create_relu6_net(**params, ir_version=ir_version,
                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data = [dict(shape=[1]),
                  dict(shape=[1, 224]),
@@ -84,8 +84,8 @@ class TestReLU6(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_relu6(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                   api_2):
+                   use_old_api):
         self._test(*self.create_relu6_net(**params, ir_version=ir_version,
                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Reduce.py

@@ -46,11 +46,11 @@ class TestReduceOps(CommonTFLayerTest):
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
     def test_reduce(self, params, keep_dims, ie_device, precision, ir_version, temp_dir,
-                    use_new_frontend, api_2):
+                    use_new_frontend, use_old_api):
         self._test(*self.create_reduce_net(**params, keep_dims=keep_dims, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_pre_commit = []
     for operation in ['sum', 'max', 'prod', 'min', 'mean']:
@@ -61,8 +61,8 @@ class TestReduceOps(CommonTFLayerTest):
     @pytest.mark.parametrize("keep_dims", [False])
     @pytest.mark.precommit
     def test_reduce_precommit(self, params, keep_dims, ie_device, precision, ir_version, temp_dir,
-                              use_new_frontend, api_2):
+                              use_new_frontend, use_old_api):
         self._test(*self.create_reduce_net(**params, keep_dims=keep_dims, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Resample_pattern_new.py

@@ -80,7 +80,7 @@ class TestResamplePattern(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.xfail(reason="*-22273")
     def test_resample(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                      api_2):
+                      use_old_api):
         self._test(*self.create_resample_net(params['shape'], params['factor'], use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_ReverseV2.py

@@ -38,9 +38,9 @@ class TestReverseV2Ops(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.parametrize("keep_dims", [True, False])
     @pytest.mark.nightly
-    def test_reversev2(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, api_2):
+    def test_reversev2(self, params, keep_dims, ie_device, precision, ir_version, temp_dir, use_old_api):
         self._test(*self.create_reversev2_net(**params, keep_dims=keep_dims, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api)
 
     test_data_pre_commit = []
     test_data_pre_commit.extend([dict(shape=[5], axis=[0]),
@@ -51,6 +51,6 @@ class TestReverseV2Ops(CommonTFLayerTest):
     @pytest.mark.parametrize("keep_dims", [True])
     @pytest.mark.precommit
     def test_reversev2_precommit(self, params, keep_dims, ie_device, precision, ir_version,
-                                 temp_dir, api_2):
+                                 temp_dir, use_old_api):
         self._test(*self.create_reversev2_net(**params, keep_dims=keep_dims, ir_version=ir_version),
-                   ie_device, precision, ir_version, temp_dir=temp_dir, api_2=api_2, use_new_frontend=False)
+                   ie_device, precision, ir_version, temp_dir=temp_dir, use_old_api=use_old_api, use_new_frontend=False)

tests/layer_tests/tensorflow_tests/test_tf_Roll.py

@@ -41,11 +41,11 @@ class TestTFRoll(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_tf_roll(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         if ie_device == 'GPU':
             pytest.skip("Roll is not supported on GPU")
         self._test(*self.create_tf_roll_net(**params, ir_version=ir_version,
                                             use_new_frontend=use_new_frontend), ie_device,
                    precision,
                    temp_dir=temp_dir, ir_version=ir_version, use_new_frontend=use_new_frontend,
-                   api_2=api_2, **params)
+                   use_old_api=use_old_api, **params)

tests/layer_tests/tensorflow_tests/test_tf_Rsqrt.py

@@ -57,11 +57,11 @@ class TestRsqrt(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_rsqrt_precommit(self, params, ie_device, precision, ir_version, temp_dir,
-                             use_new_frontend, api_2):
+                             use_new_frontend, use_old_api):
         self._test(*self.create_rsqrt_net(**params, ir_version=ir_version,
                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data = [dict(shape=[1]),
                  dict(shape=[1, 224]),
@@ -72,8 +72,8 @@ class TestRsqrt(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_rsqrt(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                   api_2):
+                   use_old_api):
         self._test(*self.create_rsqrt_net(**params, ir_version=ir_version,
                                           use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_ScatterND.py

@@ -69,8 +69,8 @@ class TestTFScatterND(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_tf_scatter_nd(self, params, ie_device, precision, ir_version, temp_dir,
-                           use_new_frontend, api_2):
+                           use_new_frontend, use_old_api):
         self._test(*self.create_tf_scatternd_placeholder_const_net(**params, ir_version=ir_version,
                                                                    use_new_frontend=use_new_frontend),
                    ie_device, precision, temp_dir=temp_dir, ir_version=ir_version,
-                   use_new_frontend=use_new_frontend, api_2=api_2, **params)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api, **params)

tests/layer_tests/tensorflow_tests/test_tf_Select.py

@@ -57,11 +57,11 @@ class TestSelect(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_select_1D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_select_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [
         dict(shape_condition=[2], shape_input=[2, 3]),
@@ -71,11 +71,11 @@ class TestSelect(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_select_2D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_select_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         dict(shape_condition=[3], shape_input=[3, 4, 5]),
@@ -85,11 +85,11 @@ class TestSelect(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_select_3D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_select_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         dict(shape_condition=[3], shape_input=[3, 4, 5, 6]),
@@ -100,11 +100,11 @@ class TestSelect(CommonTFLayerTest):
     @pytest.mark.nightly
     @pytest.mark.precommit
     def test_select_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_select_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         dict(shape_condition=[3], shape_input=[3, 4, 5, 6, 7]),
@@ -115,8 +115,8 @@ class TestSelect(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_select_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                       api_2):
+                       use_old_api):
         self._test(*self.create_select_net(**params, ir_version=ir_version,
                                            use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_Softsign.py

@@ -75,8 +75,8 @@ class TestSoftsign(CommonTFLayerTest):
     @pytest.mark.precommit
     @pytest.mark.nightly
     def test_softsign(self, params, ie_device, precision, ir_version, temp_dir,
-                      use_new_frontend, api_2):
+                      use_new_frontend, use_old_api):
         self._test(*self.create_softsign_net(**params, ir_version=ir_version,
                                              use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)

tests/layer_tests/tensorflow_tests/test_tf_SpaceToBatch.py

@@ -63,11 +63,11 @@ class TestSpaceToBatch(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_space_to_batch_4D(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         self._test(*self.create_space_to_batch_net(**params, ir_version=ir_version,
                                                    use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         dict(in_shape=[3, 3, 4, 5, 2], block_shape_value=[3, 4, 2],
@@ -81,8 +81,8 @@ class TestSpaceToBatch(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_space_to_batch_5D(self, params, ie_device, precision, ir_version, temp_dir,
-                               use_new_frontend, api_2):
+                               use_new_frontend, use_old_api):
         self._test(*self.create_space_to_batch_net(**params, ir_version=ir_version,
                                                    use_new_frontend=use_new_frontend),
                    ie_device, precision, ir_version, temp_dir=temp_dir,
-                   use_new_frontend=use_new_frontend, api_2=api_2)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)