diff --git a/tests/layer_tests/README.md b/tests/layer_tests/README.md
index d8d7960f1bb..0f4fc33e905 100644
--- a/tests/layer_tests/README.md
+++ b/tests/layer_tests/README.md
@@ -14,15 +14,19 @@ 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 TEST_DEVICE="CPU;GPU"
-    export TEST_PRECISION="FP32;FP16"
+    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"
+   ```
 
 ## Run tests
 ```bash
diff --git a/tests/layer_tests/common/layer_test_class.py b/tests/layer_tests/common/layer_test_class.py
index 6ddf7028da5..c8635a7200c 100644
--- a/tests/layer_tests/common/layer_test_class.py
+++ b/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),
diff --git a/tests/layer_tests/common/tf_layer_test_class.py b/tests/layer_tests/common/tf_layer_test_class.py
index 984fa8f2dcc..ffcf03f1c24 100644
--- a/tests/layer_tests/common/tf_layer_test_class.py
+++ b/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:
-                            key += ':0'
-                        input[key] = transpose_nchw_to_nhwc(data, self.use_new_frontend, self.api_2)
+                for key in inputs_dict.keys():
+                    data = inputs_dict.get(key)
+                    if self.use_old_api or self.use_new_frontend:
+                        key += ':0'
+                    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
diff --git a/tests/layer_tests/common/utils/common_utils.py b/tests/layer_tests/common/utils/common_utils.py
index 1bd7e33c56c..48115741f59 100644
--- a/tests/layer_tests/common/utils/common_utils.py
+++ b/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))
diff --git a/tests/layer_tests/conftest.py b/tests/layer_tests/conftest.py
index 9b52dbc4260..78c0d3a2eba 100644
--- a/tests/layer_tests/conftest.py
+++ b/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")
diff --git a/tests/layer_tests/onnx_tests/test_abs.py b/tests/layer_tests/onnx_tests/test_abs.py
index 317d3d3cf96..c8f88fd6a36 100644
--- a/tests/layer_tests/onnx_tests/test_abs.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_add_sub_mul_div.py b/tests/layer_tests/onnx_tests/test_add_sub_mul_div.py
index 3506b406207..22784c1e8c5 100644
--- a/tests/layer_tests/onnx_tests/test_add_sub_mul_div.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_and.py b/tests/layer_tests/onnx_tests/test_and.py
index 5ffcedfa1c1..26d5f770299 100644
--- a/tests/layer_tests/onnx_tests/test_and.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_argmax.py b/tests/layer_tests/onnx_tests/test_argmax.py
index 52ebeb62538..4889f330605 100644
--- a/tests/layer_tests/onnx_tests/test_argmax.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_bn.py b/tests/layer_tests/onnx_tests/test_bn.py
index 6a01d855b71..221884214ac 100644
--- a/tests/layer_tests/onnx_tests/test_bn.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_ceil.py b/tests/layer_tests/onnx_tests/test_ceil.py
index 596978409a6..d9bf2fe79d6 100644
--- a/tests/layer_tests/onnx_tests/test_ceil.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_clip.py b/tests/layer_tests/onnx_tests/test_clip.py
index 72e39ecb480..d633c772f3f 100644
--- a/tests/layer_tests/onnx_tests/test_clip.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_concat.py b/tests/layer_tests/onnx_tests/test_concat.py
index 47a61ef0f1c..843d4090746 100644
--- a/tests/layer_tests/onnx_tests/test_concat.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_conv.py b/tests/layer_tests/onnx_tests/test_conv.py
index d5e33983c5e..2fb0f06b9f8 100644
--- a/tests/layer_tests/onnx_tests/test_conv.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_conv_transpose.py b/tests/layer_tests/onnx_tests/test_conv_transpose.py
index 05342c68d09..4e3be2addcc 100644
--- a/tests/layer_tests/onnx_tests/test_conv_transpose.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_cumsum.py b/tests/layer_tests/onnx_tests/test_cumsum.py
index 99a2a7876ce..0551342b4dd 100644
--- a/tests/layer_tests/onnx_tests/test_cumsum.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_dequantize_linear.py b/tests/layer_tests/onnx_tests/test_dequantize_linear.py
index d60a8e17cdc..b4c69af55f9 100644
--- a/tests/layer_tests/onnx_tests/test_dequantize_linear.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_dropout.py b/tests/layer_tests/onnx_tests/test_dropout.py
index 468b51dd49c..4a72c4a0467 100644
--- a/tests/layer_tests/onnx_tests/test_dropout.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_elu.py b/tests/layer_tests/onnx_tests/test_elu.py
index 97212b59a5e..65b44bc66fb 100644
--- a/tests/layer_tests/onnx_tests/test_elu.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_embedding_bag.py b/tests/layer_tests/onnx_tests/test_embedding_bag.py
index 8eac46d1481..ca8d7a50eb3 100644
--- a/tests/layer_tests/onnx_tests/test_embedding_bag.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_flatten.py b/tests/layer_tests/onnx_tests/test_flatten.py
index b26643bed3b..ad67c8e198b 100644
--- a/tests/layer_tests/onnx_tests/test_flatten.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_floor.py b/tests/layer_tests/onnx_tests/test_floor.py
index 210d067f234..ae41fef3710 100644
--- a/tests/layer_tests/onnx_tests/test_floor.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_fusedgemm.py b/tests/layer_tests/onnx_tests/test_fusedgemm.py
index 7584764d33d..f84a380ac25 100644
--- a/tests/layer_tests/onnx_tests/test_fusedgemm.py
+++ b/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
 
 
@@ -134,15 +130,15 @@ class TestFusedGemm(OnnxRuntimeLayerTest):
     ]
 
     @pytest.mark.parametrize("params", test_data)
-    @pytest.mark.parametrize("alpha", [0.1,2.0])
-    @pytest.mark.parametrize("beta", [0.1,2.0])
+    @pytest.mark.parametrize("alpha", [0.1, 2.0])
+    @pytest.mark.parametrize("beta", [0.1, 2.0])
     @pytest.mark.parametrize("trans_a", [None])
     @pytest.mark.parametrize("trans_b", [None, 1])
     @pytest.mark.parametrize("opset", [None])
     @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)
diff --git a/tests/layer_tests/onnx_tests/test_gather.py b/tests/layer_tests/onnx_tests/test_gather.py
index addab999191..b46c7b3a4c1 100644
--- a/tests/layer_tests/onnx_tests/test_gather.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_gemm.py b/tests/layer_tests/onnx_tests/test_gemm.py
index d293eb378a5..a4f74d09b77 100644
--- a/tests/layer_tests/onnx_tests/test_gemm.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_hard_sigmoid.py b/tests/layer_tests/onnx_tests/test_hard_sigmoid.py
index af08041d233..e926b5f89e1 100644
--- a/tests/layer_tests/onnx_tests/test_hard_sigmoid.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_identity.py b/tests/layer_tests/onnx_tests/test_identity.py
index 9130ff8669b..b5819b7b368 100644
--- a/tests/layer_tests/onnx_tests/test_identity.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_image_scaler.py b/tests/layer_tests/onnx_tests/test_image_scaler.py
index f1a1e655514..950ef3e70d5 100644
--- a/tests/layer_tests/onnx_tests/test_image_scaler.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_instance_normalization.py b/tests/layer_tests/onnx_tests/test_instance_normalization.py
index 453922d794f..55e5d95d4bb 100644
--- a/tests/layer_tests/onnx_tests/test_instance_normalization.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_leaky_relu.py b/tests/layer_tests/onnx_tests/test_leaky_relu.py
index 2a829d5ea00..024fca1d54e 100644
--- a/tests/layer_tests/onnx_tests/test_leaky_relu.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_log.py b/tests/layer_tests/onnx_tests/test_log.py
index 3c509d49e2a..dc1b050fb4a 100644
--- a/tests/layer_tests/onnx_tests/test_log.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_logsoftmax.py b/tests/layer_tests/onnx_tests/test_logsoftmax.py
index 65f72db1178..61ac1626d75 100644
--- a/tests/layer_tests/onnx_tests/test_logsoftmax.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_loop.py b/tests/layer_tests/onnx_tests/test_loop.py
index 919b2e069db..baf0c2ae137 100644
--- a/tests/layer_tests/onnx_tests/test_loop.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_lrn.py b/tests/layer_tests/onnx_tests/test_lrn.py
index eebfe5d2e06..13b2b0e8475 100644
--- a/tests/layer_tests/onnx_tests/test_lrn.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_lstm.py b/tests/layer_tests/onnx_tests/test_lstm.py
index b65dda186df..4b487d13343 100644
--- a/tests/layer_tests/onnx_tests/test_lstm.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_matmul.py b/tests/layer_tests/onnx_tests/test_matmul.py
index dc8d13bdd00..63d2e6a0bb4 100644
--- a/tests/layer_tests/onnx_tests/test_matmul.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_mean_variance_normalization.py b/tests/layer_tests/onnx_tests/test_mean_variance_normalization.py
index e9d147291f4..0ad6630ce0f 100644
--- a/tests/layer_tests/onnx_tests/test_mean_variance_normalization.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_neg.py b/tests/layer_tests/onnx_tests/test_neg.py
index f3b2708809f..7e4f9e41198 100644
--- a/tests/layer_tests/onnx_tests/test_neg.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_non_zero.py b/tests/layer_tests/onnx_tests/test_non_zero.py
index e45e6b9e514..be589112c66 100644
--- a/tests/layer_tests/onnx_tests/test_non_zero.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_not.py b/tests/layer_tests/onnx_tests/test_not.py
index a4eaa909879..01fbf2e4f89 100644
--- a/tests/layer_tests/onnx_tests/test_not.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_or.py b/tests/layer_tests/onnx_tests/test_or.py
index 53431fd6f5c..404d1588f96 100644
--- a/tests/layer_tests/onnx_tests/test_or.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_pad.py b/tests/layer_tests/onnx_tests/test_pad.py
index 93ce197c6e6..8b84935c76f 100644
--- a/tests/layer_tests/onnx_tests/test_pad.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_pooling.py b/tests/layer_tests/onnx_tests/test_pooling.py
index 4ffe9f2bb53..fe7c419c3ff 100644
--- a/tests/layer_tests/onnx_tests/test_pooling.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_prelu.py b/tests/layer_tests/onnx_tests/test_prelu.py
index 39790ef14e8..270c2ad26c1 100644
--- a/tests/layer_tests/onnx_tests/test_prelu.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_reciprocal.py b/tests/layer_tests/onnx_tests/test_reciprocal.py
index 94a2fcfa085..ba9fb84eeb4 100644
--- a/tests/layer_tests/onnx_tests/test_reciprocal.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_reduce.py b/tests/layer_tests/onnx_tests/test_reduce.py
index 0cae89a4c93..412786e21c3 100644
--- a/tests/layer_tests/onnx_tests/test_reduce.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_reduce_lp.py b/tests/layer_tests/onnx_tests/test_reduce_lp.py
index 8e49573357f..66f76318625 100644
--- a/tests/layer_tests/onnx_tests/test_reduce_lp.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_relu.py b/tests/layer_tests/onnx_tests/test_relu.py
index 955d2a321ad..e01ecc9b0cc 100644
--- a/tests/layer_tests/onnx_tests/test_relu.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_reshape.py b/tests/layer_tests/onnx_tests/test_reshape.py
index 30de543afbc..58544803f6a 100644
--- a/tests/layer_tests/onnx_tests/test_reshape.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_resize.py b/tests/layer_tests/onnx_tests/test_resize.py
index 8ccb2c58493..3814a6e0f02 100644
--- a/tests/layer_tests/onnx_tests/test_resize.py
+++ b/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,
diff --git a/tests/layer_tests/onnx_tests/test_roi_align.py b/tests/layer_tests/onnx_tests/test_roi_align.py
index 217aecdcfc0..a8549197a04 100644
--- a/tests/layer_tests/onnx_tests/test_roi_align.py
+++ b/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,
-                        use_legacy_frontend=True)
+                       ir_version,
+                       temp_dir=temp_dir, use_old_api=use_old_api,
+                       use_legacy_frontend=True)
diff --git a/tests/layer_tests/onnx_tests/test_scale.py b/tests/layer_tests/onnx_tests/test_scale.py
index f006b9d2556..73cd20bf928 100644
--- a/tests/layer_tests/onnx_tests/test_scale.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_scatter.py b/tests/layer_tests/onnx_tests/test_scatter.py
index 2a36d1eb0cb..0e92c988815 100644
--- a/tests/layer_tests/onnx_tests/test_scatter.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_sigmoid.py b/tests/layer_tests/onnx_tests/test_sigmoid.py
index 158654cbc90..137f0603a35 100644
--- a/tests/layer_tests/onnx_tests/test_sigmoid.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_sign.py b/tests/layer_tests/onnx_tests/test_sign.py
index ada7c87522a..a82ceb3e2f3 100644
--- a/tests/layer_tests/onnx_tests/test_sign.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_slice.py b/tests/layer_tests/onnx_tests/test_slice.py
index bd66ec09c7b..20d6022dec5 100644
--- a/tests/layer_tests/onnx_tests/test_slice.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_softmax.py b/tests/layer_tests/onnx_tests/test_softmax.py
index def5882422d..e8a6048653d 100644
--- a/tests/layer_tests/onnx_tests/test_softmax.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_softplus.py b/tests/layer_tests/onnx_tests/test_softplus.py
index c4b3ef1b27c..679601ad39e 100644
--- a/tests/layer_tests/onnx_tests/test_softplus.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_softsign.py b/tests/layer_tests/onnx_tests/test_softsign.py
index 5bab41881f9..01e3d72ff18 100644
--- a/tests/layer_tests/onnx_tests/test_softsign.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_split_concat.py b/tests/layer_tests/onnx_tests/test_split_concat.py
index e80a24045e9..6848dd6fe59 100644
--- a/tests/layer_tests/onnx_tests/test_split_concat.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_sqrt.py b/tests/layer_tests/onnx_tests/test_sqrt.py
index cf13ca24032..e71d0b7e8d3 100644
--- a/tests/layer_tests/onnx_tests/test_sqrt.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_squeeze.py b/tests/layer_tests/onnx_tests/test_squeeze.py
index d2afbc634a4..a46b35d7a06 100644
--- a/tests/layer_tests/onnx_tests/test_squeeze.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_sum.py b/tests/layer_tests/onnx_tests/test_sum.py
index a5dcac53644..a849b1294d2 100644
--- a/tests/layer_tests/onnx_tests/test_sum.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_topk.py b/tests/layer_tests/onnx_tests/test_topk.py
index f08b0047961..5c6bfd2ce87 100644
--- a/tests/layer_tests/onnx_tests/test_topk.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_transpose.py b/tests/layer_tests/onnx_tests/test_transpose.py
index 6f3da4d1226..51fdad4f230 100644
--- a/tests/layer_tests/onnx_tests/test_transpose.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_trigonometry.py b/tests/layer_tests/onnx_tests/test_trigonometry.py
index 451d4136a4f..f1a848fa7f5 100644
--- a/tests/layer_tests/onnx_tests/test_trigonometry.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_unsqueeze.py b/tests/layer_tests/onnx_tests/test_unsqueeze.py
index ac7e0822492..7bb1f2e2e0a 100644
--- a/tests/layer_tests/onnx_tests/test_unsqueeze.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_upsample.py b/tests/layer_tests/onnx_tests/test_upsample.py
index 9825790e280..0942dfd01b9 100644
--- a/tests/layer_tests/onnx_tests/test_upsample.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_where.py b/tests/layer_tests/onnx_tests/test_where.py
index f3538fbb56f..c95dae54445 100644
--- a/tests/layer_tests/onnx_tests/test_where.py
+++ b/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)
diff --git a/tests/layer_tests/onnx_tests/test_xor.py b/tests/layer_tests/onnx_tests/test_xor.py
index 5910ef29781..572f0953687 100644
--- a/tests/layer_tests/onnx_tests/test_xor.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/conftest.py b/tests/layer_tests/tensorflow_tests/conftest.py
index a589aa3cac7..cc957ad4aac 100644
--- a/tests/layer_tests/tensorflow_tests/conftest.py
+++ b/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
-    try:
-        import openvino.runtime as rt
-    except ImportError as err:
-        raise Exception("Please set PYTHONPATH to OpenVINO Python") 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')]
+    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:
-        tf_fe_lib_names = [('libopenvino_tensorflow_fe.so', 'libopenvino_tensorflow_frontend.so')]
+        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 or install wheel package "
+                            "or use OV_FRONTEND_PATH env variable") from err
+
+    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])
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Add.py b/tests/layer_tests/tensorflow_tests/test_tf_Add.py
index cef12a1c6fc..a629cde62af 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Add.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BatchToSpace.py b/tests/layer_tests/tensorflow_tests/test_tf_BatchToSpace.py
index 3dea2636dec..7323295d752 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_BatchToSpace.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BiasAdd.py b/tests/layer_tests/tensorflow_tests/test_tf_BiasAdd.py
index 7f65f1f3fc5..72f809aa023 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_BiasAdd.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py b/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py
index 7d8dc05a2dd..ab47a4d35a6 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_BinaryOps.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py b/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py
index a17a4bde745..926a87df1dd 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Bucketize.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Concat.py b/tests/layer_tests/tensorflow_tests/test_tf_Concat.py
index fc9ff99d95c..589371d75c1 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Concat.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Eltwise.py b/tests/layer_tests/tensorflow_tests/test_tf_Eltwise.py
index 15e9848b09f..c66c55c8210 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Eltwise.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Eye.py b/tests/layer_tests/tensorflow_tests/test_tf_Eye.py
index 16c72f6699c..a3f26b7536b 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Eye.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_FakeQuantize.py b/tests/layer_tests/tensorflow_tests/test_tf_FakeQuantize.py
index 2a606de4a75..64d2c750826 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_FakeQuantize.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_GRUBlockCell.py b/tests/layer_tests/tensorflow_tests/test_tf_GRUBlockCell.py
index 6304509a060..52249e305f2 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_GRUBlockCell.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Gather.py b/tests/layer_tests/tensorflow_tests/test_tf_Gather.py
index e60334aded5..5a505838ad6 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Gather.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Identity.py b/tests/layer_tests/tensorflow_tests/test_tf_Identity.py
index cf0ec0ee5f3..5b5dce2f1a5 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Identity.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_LogSoftmax.py b/tests/layer_tests/tensorflow_tests/test_tf_LogSoftmax.py
index 7da54cbbc7c..a1dad1e7894 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_LogSoftmax.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Mul.py b/tests/layer_tests/tensorflow_tests/test_tf_Mul.py
index 02b96a1cfbf..86194f8f9e9 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Mul.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_NonMaxSupression.py b/tests/layer_tests/tensorflow_tests/test_tf_NonMaxSupression.py
index 61ac7b99012..b3a06eb9478 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_NonMaxSupression.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_NormalizeL2.py b/tests/layer_tests/tensorflow_tests/test_tf_NormalizeL2.py
index 804ac10110d..c7247a4557a 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_NormalizeL2.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_OneHot.py b/tests/layer_tests/tensorflow_tests/test_tf_OneHot.py
index d9153006343..e31b3dac7be 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_OneHot.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Pooling.py b/tests/layer_tests/tensorflow_tests/test_tf_Pooling.py
index 5bd70fa2087..dbe222f9728 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Pooling.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_RandomUniform.py b/tests/layer_tests/tensorflow_tests/test_tf_RandomUniform.py
index f4c7a16bb3f..f45c8b5688d 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_RandomUniform.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_ReLU6.py b/tests/layer_tests/tensorflow_tests/test_tf_ReLU6.py
index b334c57c487..b784ceda81d 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_ReLU6.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Reduce.py b/tests/layer_tests/tensorflow_tests/test_tf_Reduce.py
index fa890381463..270a1f624f5 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Reduce.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Resample_pattern_new.py b/tests/layer_tests/tensorflow_tests/test_tf_Resample_pattern_new.py
index d71d3cdf2e1..d75fac0d393 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Resample_pattern_new.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_ReverseV2.py b/tests/layer_tests/tensorflow_tests/test_tf_ReverseV2.py
index 1594b7132e4..b3194544ba9 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_ReverseV2.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Roll.py b/tests/layer_tests/tensorflow_tests/test_tf_Roll.py
index 1634aa92ab9..d1681e25470 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Roll.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Rsqrt.py b/tests/layer_tests/tensorflow_tests/test_tf_Rsqrt.py
index a2540a14c87..82db2f5a860 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Rsqrt.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_ScatterND.py b/tests/layer_tests/tensorflow_tests/test_tf_ScatterND.py
index 0144c827c90..5a0382551e2 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_ScatterND.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Select.py b/tests/layer_tests/tensorflow_tests/test_tf_Select.py
index d6018bbbaa1..204fb398ef4 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Select.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Softsign.py b/tests/layer_tests/tensorflow_tests/test_tf_Softsign.py
index 30d909695ed..dbc9dfa0e86 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Softsign.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_Softsign.py
@@ -66,17 +66,17 @@ class TestSoftsign(CommonTFLayerTest):
 
     @pytest.mark.parametrize("params",
                              [
-                              dict(shape=[1]),
-                              dict(shape=[1, 224]),
-                              dict(shape=[1, 3, 224]),
-                              dict(shape=[1, 3, 100, 224]),
-                              dict(shape=[1, 3, 50, 100, 224]),
+                                 dict(shape=[1]),
+                                 dict(shape=[1, 224]),
+                                 dict(shape=[1, 3, 224]),
+                                 dict(shape=[1, 3, 100, 224]),
+                                 dict(shape=[1, 3, 50, 100, 224]),
                              ])
     @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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_SpaceToBatch.py b/tests/layer_tests/tensorflow_tests/test_tf_SpaceToBatch.py
index b57a660f4e1..eb017f3ed4f 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_SpaceToBatch.py
+++ b/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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Squeeze.py b/tests/layer_tests/tensorflow_tests/test_tf_Squeeze.py
index 2ec760aa6d2..224477ca87a 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Squeeze.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_Squeeze.py
@@ -55,11 +55,11 @@ class TestSqueeze(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_squeeze_1D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                        api_2):
+                        use_old_api):
         self._test(*self.create_squeeze_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 = [
         pytest.param(dict(shape=[1, 1], axis=[]), marks=pytest.mark.xfail(reason="*-18807")),
@@ -70,11 +70,11 @@ class TestSqueeze(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_squeeze_2D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                        api_2):
+                        use_old_api):
         self._test(*self.create_squeeze_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, 3], axis=[]),
@@ -88,11 +88,11 @@ class TestSqueeze(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_squeeze_3D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                        api_2):
+                        use_old_api):
         self._test(*self.create_squeeze_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 = [
         pytest.param(dict(shape=[1, 1, 50, 100], axis=[]),
@@ -106,11 +106,11 @@ class TestSqueeze(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_squeeze_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                        api_2):
+                        use_old_api):
         self._test(*self.create_squeeze_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 = [
         pytest.param(dict(shape=[1, 1, 50, 100, 224], axis=[]),
@@ -135,8 +135,8 @@ class TestSqueeze(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_squeeze_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                        api_2):
+                        use_old_api):
         self._test(*self.create_squeeze_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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_StridedSlice.py b/tests/layer_tests/tensorflow_tests/test_tf_StridedSlice.py
index d9045642635..45186cd51c4 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_StridedSlice.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_StridedSlice.py
@@ -70,11 +70,11 @@ class TestStridedSlice(CommonTFLayerTest):
     @pytest.mark.parametrize('params', test_squeeze_data)
     @pytest.mark.nightly
     def test_strided_slice_replace_with_squeeze(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_strided_slice_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_unsqueeze_data = [
         dict(input_shape=[1, 5], begin=[0, 0], end=[1, 5], strides=[1, 1], begin_mask=0,
@@ -104,8 +104,8 @@ class TestStridedSlice(CommonTFLayerTest):
     @pytest.mark.parametrize('params', test_unsqueeze_data)
     @pytest.mark.nightly
     def test_strided_slice_replace_with_unsqueeze(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_strided_slice_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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Sub.py b/tests/layer_tests/tensorflow_tests/test_tf_Sub.py
index 5227d649d6c..a5c0a4fe46b 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Sub.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_Sub.py
@@ -70,11 +70,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_2D = [
         # Power
@@ -91,11 +91,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_3D = [
         # Power
@@ -116,11 +116,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_4D = [
         # Power
@@ -138,11 +138,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_5D = [
         # Power
@@ -160,11 +160,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     ###############################################################################################
     #                                                                                             #
@@ -179,11 +179,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_1D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_2D = [
         # Power
@@ -202,11 +202,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_2D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_3D = [
         # Power
@@ -235,11 +235,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_3D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_4D = [
         # Power
@@ -269,11 +269,11 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_4D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data_broadcast_5D = [
         # Power
@@ -301,8 +301,8 @@ class TestSub(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_broadcast_5D)
     @pytest.mark.nightly
     def test_sub_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_sub_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)
+                   temp_dir=temp_dir, use_new_frontend=use_new_frontend, use_old_api=use_old_api)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_Swish.py b/tests/layer_tests/tensorflow_tests/test_tf_Swish.py
index 4cd998e4edb..2e14438641b 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_Swish.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_Swish.py
@@ -72,11 +72,11 @@ class TestSwish(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_precommit)
     @pytest.mark.precommit
     def test_swish_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_swish_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]),
@@ -87,8 +87,8 @@ class TestSwish(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data)
     @pytest.mark.nightly
     def test_swish(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                   api_2):
+                   use_old_api):
         self._test(*self.create_swish_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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_TopK.py b/tests/layer_tests/tensorflow_tests/test_tf_TopK.py
index 261e5547e19..7b1d03b5bda 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_TopK.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_TopK.py
@@ -97,11 +97,11 @@ class Test_TopK(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_1D)
     @pytest.mark.nightly
     def test_TopK_1D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_topK_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=[14, 15], k=10),
@@ -111,11 +111,11 @@ class Test_TopK(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_2D)
     @pytest.mark.nightly
     def test_TopK_2D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_topK_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=[13, 14, 15], k=10),
@@ -125,11 +125,11 @@ class Test_TopK(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_3D)
     @pytest.mark.nightly
     def test_TopK_3D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_topK_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=[12, 13, 14, 15], k=10),
@@ -139,11 +139,11 @@ class Test_TopK(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_4D)
     @pytest.mark.nightly
     def test_TopK_4D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_topK_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=[11, 12, 13, 14, 15], k=10),
@@ -153,8 +153,8 @@ class Test_TopK(CommonTFLayerTest):
     @pytest.mark.parametrize("params", test_data_5D)
     @pytest.mark.nightly
     def test_TopK_5D(self, params, ie_device, precision, ir_version, temp_dir, use_new_frontend,
-                     api_2):
+                     use_old_api):
         self._test(*self.create_topK_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)
diff --git a/tests/layer_tests/tensorflow_tests/test_tf_UnaryOps.py b/tests/layer_tests/tensorflow_tests/test_tf_UnaryOps.py
index ab0b47156a4..47d1da0a127 100644
--- a/tests/layer_tests/tensorflow_tests/test_tf_UnaryOps.py
+++ b/tests/layer_tests/tensorflow_tests/test_tf_UnaryOps.py
@@ -158,13 +158,13 @@ class TestUnaryOps(CommonTFLayerTest):
                                          ])
     @pytest.mark.precommit
     def test_unary_op_precommit(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':
             pytest.skip("5D tensors is not supported on GPU")
         self._test(*self.create_net_with_unary_op(**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)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)
 
     test_data = [dict(shape=[10, 12]),
                  dict(shape=[8, 10, 12]),
@@ -198,10 +198,10 @@ class TestUnaryOps(CommonTFLayerTest):
                                          'Asinh'])
     @pytest.mark.nightly
     def test_unary_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':
             pytest.skip("5D tensors is not supported on GPU")
         self._test(*self.create_net_with_unary_op(**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)
+                   use_new_frontend=use_new_frontend, use_old_api=use_old_api)